diff --git a/AdbExtension/Package.appxmanifest b/AdbExtension/Package.appxmanifest index a7a531d..42402bf 100644 --- a/AdbExtension/Package.appxmanifest +++ b/AdbExtension/Package.appxmanifest @@ -11,12 +11,12 @@ + Version="1.0.0.0" /> - ADB Extension + ADB Extension for Command Palette A Lone Developer Assets\StoreLogo.png @@ -35,8 +35,8 @@ Executable="$targetnametoken$.exe" EntryPoint="$targetentrypoint$"> @@ -46,8 +46,8 @@ - - + + @@ -55,8 +55,8 @@ + DisplayName="ADB Extension for Command Palette" + Description="Run ADB commands for connected Android devices directly from Command Palette."> diff --git a/publishing_checklist.md b/publishing_checklist.md new file mode 100644 index 0000000..d0a8ecd --- /dev/null +++ b/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 + + + + ... + +``` + +**Update `AdbExtension.csproj`** — add to the first unconditional ``: +```xml +true + +Always +x64|ARM64 +``` + +--- + +### 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 ``: +- Remove: `win-$(Platform).pubxml` +- Add: `None` + +### 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 "" "" +``` +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 diff --git a/publishing_guide.md b/publishing_guide.md new file mode 100644 index 0000000..e55a9fe --- /dev/null +++ b/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 `\Package.appxmanifest` in your IDE. +2. Replace the Identity and Properties values with the ones you copied from Partner Center. + +**Update `.csproj`:** +1. Open `.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 ``, add the required additional entries. + +--- + +### Phase 4: Build the MSIX Package + +1. In the terminal, navigate to the `\` 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 `__x64.msix` and `__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 __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 +- ✅ `.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 `.csproj`** — from the ``: +1. Remove: `win-$(Platform).pubxml` +2. Add: `None` + +**Locate your CLSID:** +1. Open your extension's main `.cs` file (e.g., `.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 `.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 `.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 **" + ``` +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 "" "" + ``` +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. \ No newline at end of file