Prepare for publishing

AdbExtension/Package.appxmanifest

@@ -11,12 +11,12 @@
   <Identity
     Name="AdbExtension"
     Publisher="CN=Microsoft Corporation, O=Microsoft Corporation, L=Redmond, S=Washington, C=US"
-    Version="0.0.1.0" />
+    Version="1.0.0.0" />
   <!-- When you're ready to publish your extension, you'll need to change the
        Publisher= to match your own identity -->
 
   <Properties>
-    <DisplayName>ADB Extension</DisplayName>
+    <DisplayName>ADB Extension for Command Palette</DisplayName>
     <PublisherDisplayName>A Lone Developer</PublisherDisplayName>
     <Logo>Assets\StoreLogo.png</Logo>
   </Properties>
@@ -35,8 +35,8 @@
       Executable="$targetnametoken$.exe"
       EntryPoint="$targetentrypoint$">
       <uap:VisualElements
-        DisplayName="ADB Extension"
-        Description="ADB Extension"
+        DisplayName="ADB Extension for Command Palette"
+        Description="Run ADB commands for connected Android devices directly from Command Palette."
         BackgroundColor="transparent"
         Square150x150Logo="Assets\Square150x150Logo.png"
         Square44x44Logo="Assets\Square44x44Logo.png">
@@ -46,17 +46,17 @@
       <Extensions>
         <com:Extension Category="windows.comServer">
           <com:ComServer>
-            <com:ExeServer Executable="AdbExtension.exe" Arguments="-RegisterProcessAsComServer" DisplayName="ADB Extension">
-              <com:Class Id="d857a76b-60ad-4db5-a14c-22f1d4f7bfaa" DisplayName="ADB Extension" />
+            <com:ExeServer Executable="AdbExtension.exe" Arguments="-RegisterProcessAsComServer" DisplayName="ADB Extension for Command Palette">
+              <com:Class Id="d857a76b-60ad-4db5-a14c-22f1d4f7bfaa" DisplayName="ADB Extension for Command Palette" />
             </com:ExeServer>
           </com:ComServer>
         </com:Extension>
         <uap3:Extension Category="windows.appExtension">
           <uap3:AppExtension Name="com.microsoft.commandpalette"
             Id="ID"
             PublicFolder="Public"
-            DisplayName="ADB Extension"
-            Description="ADB Extension">
+            DisplayName="ADB Extension for Command Palette"
+            Description="Run ADB commands for connected Android devices directly from Command Palette.">
             <uap3:Properties>
               <CmdPalProvider>
                 <Activation>

publishing_checklist.md

@@ -0,0 +1,118 @@
+# Publishing Prep Plan — ADB Quick Commands
+
+## Context
+
+The extension was scaffolded from Microsoft's template, which leaves several placeholder/default values in the manifest and csproj. Before submitting to Partner Center or WinGet, these need to be cleaned up. Some changes can be made immediately; others require first registering in Partner Center to get your Publisher identity.
+
+---
+
+## Track A: Microsoft Store (MSIX bundle)
+
+### ~~Step 1 — Fixes you can do RIGHT NOW~~ ✅ DONE
+
+**`AdbExtension/Package.appxmanifest`** — all updated:
+- Version: `1.0.0.0`
+- All display names: `ADB Extension for Command Palette`
+- All descriptions: `Run ADB commands for connected Android devices directly from Command Palette.`
+
+> **Note:** `Identity/Name`, `Identity/Publisher`, and `Properties/PublisherDisplayName` are left as scaffold defaults — fill in after Partner Center registration (Step 2).
+
+**Assets (`AdbExtension/Assets/`)** — all 7 files are generic Microsoft template images. Replace with custom branding. Required files:
+- `StoreLogo.png`
+- `Square44x44Logo.scale-200.png`
+- `Square44x44Logo.targetsize-24_altform-unplated.png`
+- `Square150x150Logo.scale-200.png`
+- `Wide310x150Logo.scale-200.png`
+- `SplashScreen.scale-200.png`
+- `LockScreenLogo.scale-200.png`
+
+---
+
+### Step 2 — After Partner Center registration
+
+1. Register in **Microsoft Partner Center** → Apps and games → New Product → MSIX or PWA app.
+2. Reserve product name (e.g. `ADB Extension for Command Palette`).
+3. From **Product Management → Product identity**, copy:
+   - `Package/Identity/Name`
+   - `Package/Identity/Publisher`
+   - `Package/Properties/PublisherDisplayName`
+
+**Update `Package.appxmanifest`** with copied values:
+```xml
+<Identity
+  Name="<from Partner Center>"
+  Publisher="<from Partner Center>"
+  Version="1.0.0.0" />
+<Properties>
+  <PublisherDisplayName><from Partner Center></PublisherDisplayName>
+  ...
+</Properties>
+```
+
+**Update `AdbExtension.csproj`** — add to the first unconditional `<PropertyGroup>`:
+```xml
+<AppxPackageSigningEnabled>true</AppxPackageSigningEnabled>
+<PackageCertificateThumbprint></PackageCertificateThumbprint>
+<AppxBundle>Always</AppxBundle>
+<AppxBundlePlatforms>x64|ARM64</AppxBundlePlatforms>
+```
+
+---
+
+### Step 3 — Build MSIX bundle
+
+```
+cd AdbExtension\AdbExtension
+dotnet build --configuration Release -p:GenerateAppxPackageOnBuild=true -p:Platform=x64 -p:AppxPackageDir="AppPackages\x64\"
+dotnet build --configuration Release -p:GenerateAppxPackageOnBuild=true -p:Platform=ARM64 -p:AppxPackageDir="AppPackages\ARM64\"
+makeappx bundle /v /d bin\Release\ /p AdbExtensionForCommandPalette_1.0.0.0_Bundle.msixbundle
+```
+
+Upload `.msixbundle` to Partner Center. In the Store description, note that reviewer needs PowerToys + Command Palette installed.
+
+---
+
+## Track B: WinGet (EXE installer via Inno Setup + GitHub Actions)
+
+### Step 4 — Modify csproj for WinGet publishing
+
+In `AdbExtension/AdbExtension.csproj`, in the first `<PropertyGroup>`:
+- Remove: `<PublishProfile>win-$(Platform).pubxml</PublishProfile>`
+- Add: `<WindowsPackageType>None</WindowsPackageType>`
+
+### Step 5 — Create build scripts
+
+Create in `AdbExtension/AdbExtension/`:
+- `setup-template.iss` — Inno Setup installer config (use template from MS docs, fill in CLSID `d857a76b-60ad-4db5-a14c-22f1d4f7bfaa` and app metadata)
+- `build-exe.ps1` — PowerShell build script (setup .NET + Inno Setup → dotnet publish → create installer → upload)
+
+### Step 6 — Create GitHub Actions workflow
+
+Create `.github/workflows/release-extension.yml` — automates: build → package → create GitHub Release with x64 + ARM64 `.exe` assets.
+
+### Step 7 — WinGet first submission
+
+After the GitHub Release is created:
+```
+wingetcreate new "<x64 .exe URL>" "<arm64 .exe URL>"
+```
+Follow prompts, add tag `windows-commandpalette-extension` to locale YAML files before submitting.
+
+---
+
+## Critical files to modify
+
+| File | Changes |
+|---|---|
+| `AdbExtension/Package.appxmanifest` | DisplayName, Description, Version, Publisher identity (post-Partner Center) |
+| `AdbExtension/AdbExtension.csproj` | AppxPackage properties (post-Partner Center), WindowsPackageType swap for WinGet |
+| `AdbExtension/Assets/*.png` | Replace all 7 with custom branding |
+| `AdbExtension/AdbExtension/setup-template.iss` | Create new |
+| `AdbExtension/AdbExtension/build-exe.ps1` | Create new |
+| `.github/workflows/release-extension.yml` | Create new |
+
+## Verification
+
+- After Step 1: Deploy the MSIX and reload Command Palette — confirm display names are updated throughout
+- After Step 3: `dir *.msixbundle` confirms bundle was created; upload to Partner Center submission
+- After Step 6: Trigger `gh workflow run release-extension.yml` and confirm both `.exe` assets appear in the GitHub Release

publishing_guide.md

@@ -0,0 +1,179 @@
+Here's your complete step-by-step publishing guide based on the Microsoft docs. You have two distribution options (Microsoft Store and/or WinGet) — the docs recommend doing both. I've laid them out sequentially.
+
+---
+
+## Part 1 — Publish to the Microsoft Store
+
+### Phase 1: Prerequisites
+
+1. Register as a Windows app developer in **Microsoft Partner Center** (if you haven't already).
+2. Generate all required app icons using Visual Studio's asset generation tool, making sure all required sizes and variations are included.
+
+---
+
+### Phase 2: Set Up Your Microsoft Store Listing
+
+1. Go to **Microsoft Partner Center**.
+2. Under **Workspaces**, select **Apps and games**.
+3. Select **+ New Product**.
+4. Choose **MSIX or PWA app**.
+5. Create or reserve a product name.
+6. Start the submission and fill in as much as you can until you reach the **Packages** section.
+7. In the left nav, under **Product Management**, select **Product identity**.
+8. Copy these three values for use in the next steps:
+    - `Package/Identity/Name`
+    - `Package/Identity/Publisher`
+    - `Package/Properties/PublisherDisplayName`
+
+---
+
+### Phase 3: Prepare the Extension
+
+**Update `Package.appxmanifest`:**
+1. Open `<ExtensionName>\Package.appxmanifest` in your IDE.
+2. Replace the Identity and Properties values with the ones you copied from Partner Center.
+
+**Update `<ExtensionName>.csproj`:**
+1. Open `<ExtensionName>.csproj`.
+2. Find a `PropertyGroup` element (with no conditions) and add the AppxPackage properties using your Partner Center values.
+3. Update the `ItemGroup` for images to include all of them.
+4. Under that `<ItemGroup>`, add the required additional entries.
+
+---
+
+### Phase 4: Build the MSIX Package
+
+1. In the terminal, navigate to the `<ExtensionName>\<ExtensionName>` directory.
+2. Build for **x64**:
+   ```
+   dotnet build --configuration Release -p:GenerateAppxPackageOnBuild=true -p:Platform=x64 -p:AppxPackageDir="AppPackages\x64\"
+   ```
+3. Build for **ARM64**:
+   ```
+   dotnet build --configuration Release -p:GenerateAppxPackageOnBuild=true -p:Platform=ARM64 -p:AppxPackageDir="AppPackages\ARM64\"
+   ```
+4. Locate your MSIX files:
+   ```
+   dir AppPackages -Recurse -Filter "*.msix"
+   ```
+5. Note the paths to both `<ExtensionName>_<VersionNumber>_x64.msix` and `<ExtensionName>_<VersionNumber>_arm64.msix`.
+6. In the same directory, create a `bundle_mapping.txt` file with the paths to both MSIX files.
+7. Create an **MSIX bundle** combining both architectures:
+   ```
+   makeappx bundle /v /d bin\Release\ /p <ExtensionName>_<VersionNumber>_Bundle.msixbundle
+   ```
+   *(If `makeappx` isn't recognized, locate it on your machine and use the full path.)*
+8. Verify the bundle exists:
+   ```
+   dir *.msixbundle
+   ```
+
+**Validation checklist before continuing:**
+- ✅ `Package.appxmanifest` updated with correct Identity and Properties
+- ✅ `<ExtensionName>.csproj` updated with AppxPackage properties
+- ✅ Both x64 and ARM64 MSIX files built successfully
+- ✅ `bundle_mapping.txt` contains correct paths
+- ✅ `.msixbundle` file was created without errors
+
+---
+
+### Phase 5: Submit to the Microsoft Store
+
+1. Go back to your Partner Center submission and open the **Packages** section.
+2. Upload the `.msixbundle` file you created.
+3. Complete the rest of the submission. Key tips:
+    - In **Description**, include a line like: *"[ExtensionName] integrates with the Windows Command Palette to..."*
+    - Under **Supplemental info → Additional Testing Information**, add a note that the reviewer needs **PowerToys** and **Command Palette** installed to test your extension (with setup instructions).
+4. Submit your extension. Microsoft will review it for certification — monitor status in Partner Center and watch for email notifications. Once approved, it goes live within a few hours.
+
+---
+
+## Part 2 — Publish to WinGet
+
+WinGet is the **recommended** distribution method because it enables automatic discovery and `winget install` directly from Command Palette.
+
+---
+
+### Phase 6: Install Prerequisites (WinGet path)
+
+Install two tools if you don't have them:
+- **GitHub CLI** (`gh`)
+- **WinGetCreate**:
+  ```
+  winget install Microsoft.WingetCreate
+  ```
+
+---
+
+### Phase 7: Prepare the Project for WinGet
+
+**Modify `<ExtensionName>.csproj`** — from the `<PropertyGroup>`:
+1. Remove: `<PublishProfile>win-$(Platform).pubxml</PublishProfile>`
+2. Add: `<WindowsPackageType>None</WindowsPackageType>`
+
+**Locate your CLSID:**
+1. Open your extension's main `.cs` file (e.g., `<ExtensionName>.cs`).
+2. Find the `[Guid("...")]` attribute above the class declaration — that GUID is your CLSID. Note it down.
+
+**Create build files** (ensure you are in the directory containing your `<ExtensionName>.cs`):
+1. Create a `setup-template.iss` file (use the Inno Setup template from the docs, customized with your values).
+2. Create a `build-exe.ps1` file (use the PowerShell template from the docs). This script handles: Setup (.NET, Inno Setup) → Get Version → Build App (`dotnet publish`) → Create Installer (Inno Setup) → Upload Results.
+
+*(You can test this process locally by installing .NET 9 and Inno Setup.)*
+
+---
+
+### Phase 8: Set Up GitHub Actions Automation
+
+1. From your project root, run `cd ..` to go up to the directory containing `<ExtensionName>.sln`.
+2. Create a new GitHub repo for your extension (if you don't have one).
+3. In the `.github/workflows/` directory, create a new file called `release-extension.yml`.
+4. Add the GitHub Actions workflow content from the docs to this file. It automates: setup → build → create installer → upload to GitHub Release.
+5. Update all placeholder values in `release-extension.yml`.
+6. Commit all three new files: `build-exe.ps1`, `setup-template.iss`, and `release-extension.yml`.
+7. Push changes to GitHub.
+8. Trigger the GitHub Action:
+   ```
+   gh workflow run release-extension.yml --ref main -f create_release=true -f "release_notes= **First Release of <ExtensionName>**"
+   ```
+9. Verify it ran successfully in GitHub Actions (typical build time: 5–10 minutes). Check that the installer EXE is created and uploaded to the GitHub Release.
+
+---
+
+### Phase 9: WinGet Submission — First Version (Manual)
+
+> ⚠️ The first submission must be done manually — `wingetcreate new` requires interactive input.
+
+**Add required WinGet tags to your manifest** (before submitting):
+- In each `.locale.*.yaml` file, add the tag: `windows-commandpalette-extension`
+- In your `.installer.yaml`, add Windows App SDK as a dependency (if your extension uses it).
+
+**Run wingetcreate:**
+1. Get the GitHub Release download URLs for both your x64 and arm64 `.exe` files (go to your release page → Assets → right-click the `.exe` → Copy link address).
+2. Run:
+   ```
+   wingetcreate new "<PATH TO x64 .exe file>" "<PATH TO arm64 .exe file>"
+   ```
+3. When prompted, press **Enter** to accept auto-detected values (PackageIdentifier, PackageVersion, Publisher, etc.).
+4. For optional modification questions, answer **No**:
+    - "Would you like to modify the optional default locale fields?" → **No**
+    - "Would you like to modify the optional installer fields?" → **No**
+    - "Would you like to make changes to this manifest?" → **No**
+5. Final question: "Would you like to submit your manifest to the Windows Package Manager repository?" → **Yes**
+
+**What happens after submission:**
+- `wingetcreate` forks `microsoft/winget-pkgs` to your GitHub account
+- Creates a branch with your package manifests
+- Opens a PR automatically and gives you the PR URL
+
+6. Monitor the PR. The WinGet team reviews for compliance — respond to any reviewer feedback. Once approved and merged, your extension is available via `winget install` within a few hours.
+
+---
+
+### Phase 10: Future Updates (Automated via GitHub Actions)
+
+For all future versions, you can automate WinGet updates using the `update-winget.yml` GitHub Actions workflow. The docs include a ready-made template at `.github\workflows\update-winget.yml`. You can also reference how the PowerToys project itself handles this as a real-world example.
+
+---
+
+That's the full flow. The two big milestones are: (1) get your `.msixbundle` uploaded to Partner Center, and (2) get your first `wingetcreate new` PR merged into `winget-pkgs`. Everything after that is largely automated.