Republish extension as universal (#8)

* Republish extension as universal

* Fix cross-platform release tests

---------

Co-authored-by: thinksyncs <develop@toppymicros.com>

Author: thinksyncs

.github/workflows/daily-release.yml

@@ -223,3 +223,12 @@ jobs:
         env:
           VSCE_PAT: ${{ secrets.VSCE_PAT }}
         run: npm run publish:extension -- --packagePath workspace-guard.vsix --pre-release
+
+      - name: Verify Marketplace prerelease
+        run: |
+          npm run verify:marketplace-release -- \
+            --publisher ToppyMicroServices \
+            --name workspace-guard \
+            --version "$DAILY_VERSION" \
+            --mode universal
+

.github/workflows/release.yml

@@ -53,24 +53,14 @@ jobs:
           VSCE_PAT: ${{ secrets.VSCE_PAT }}
         run: npm run publish:extension -- --packagePath workspace-guard.vsix
 
-      - name: Verify Marketplace version
+      - name: Verify Marketplace release
         run: |
           EXPECTED_VERSION="$(node -p "require('./package.json').version")"
-
-          for attempt in $(seq 1 45); do
-            PUBLISHED_VERSION="$(npx @vscode/vsce show ToppyMicroServices.workspace-guard --json | node -e "let data=''; process.stdin.on('data', (chunk) => data += chunk); process.stdin.on('end', () => { const payload = JSON.parse(data); process.stdout.write(payload.versions?.[0]?.version ?? ''); });")"
-
-            if [ "$PUBLISHED_VERSION" = "$EXPECTED_VERSION" ]; then
-              echo "Marketplace shows version $PUBLISHED_VERSION."
-              exit 0
-            fi
-
-            echo "Marketplace still shows '$PUBLISHED_VERSION'; waiting for '$EXPECTED_VERSION' (attempt $attempt/45)."
-            sleep 20
-          done
-
-          echo "Marketplace did not publish expected version $EXPECTED_VERSION." >&2
-          exit 1
+          npm run verify:marketplace-release -- \
+            --publisher ToppyMicroServices \
+            --name workspace-guard \
+            --version "$EXPECTED_VERSION" \
+            --mode universal
 
       - name: Upload VSIX to GitHub release
         env:

package-lock.json

@@ -1,12 +1,11 @@
 {
   "name": "workspace-guard",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "private": true,
   "displayName": "Workspace Guard",
-  "preview": true,
   "publisher": "ToppyMicroServices",
   "license": "Apache-2.0",
-  "description": "Preview: Warn before VS Code opens your home directory or other high-risk folders, and offer privacy hardening for telemetry-related settings.",
+  "description": "Warn before VS Code opens your home directory or other high-risk folders, and offer privacy hardening for telemetry-related settings.",
   "icon": "assets/workspace-guard-icon.png",
   "main": "./dist/src/vscodeExtension.js",
   "engines": {
@@ -223,7 +222,8 @@
     "test": "vitest run",
     "vscode:prepublish": "npm run build",
     "package:extension": "vsce package",
-    "publish:extension": "vsce publish"
+    "publish:extension": "vsce publish",
+    "verify:marketplace-release": "node scripts/verify-marketplace-release.mjs"
   },
   "repository": {
     "type": "git",

package.json

@@ -0,0 +1,165 @@
+import process from 'node:process';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+
+const execFileAsync = promisify(execFile);
+
+function parseArgs(argv) {
+  const args = new Map();
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (!token.startsWith('--')) {
+      continue;
+    }
+
+    const key = token.slice(2);
+    const value = argv[index + 1];
+    if (!value || value.startsWith('--')) {
+      throw new Error(`Missing value for --${key}`);
+    }
+
+    args.set(key, value);
+    index += 1;
+  }
+
+  return args;
+}
+
+function sleep(milliseconds) {
+  return new Promise(resolve => setTimeout(resolve, milliseconds));
+}
+
+async function showExtension(extensionId) {
+  const { stdout } = await execFileAsync(
+    'npx',
+    ['@vscode/vsce', 'show', extensionId, '--json'],
+    {
+      cwd: process.cwd(),
+      maxBuffer: 1024 * 1024,
+      env: process.env,
+    },
+  );
+
+  return JSON.parse(stdout);
+}
+
+async function fetchPackage(url) {
+  const response = await fetch(url, {
+    headers: {
+      Accept: 'application/vsix, application/octet-stream;q=0.9, */*;q=0.1',
+    },
+    redirect: 'follow',
+  });
+
+  return response;
+}
+
+function normalizeTargets(versions, version) {
+  return versions
+    .filter(candidate => candidate.version === version)
+    .map(candidate => candidate.targetPlatform)
+    .filter(Boolean)
+    .sort();
+}
+
+function compareTargets(actualTargets, expectedTargets) {
+  const actual = new Set(actualTargets);
+  const expected = new Set(expectedTargets);
+
+  const missing = expectedTargets.filter(target => !actual.has(target));
+  const unexpected = actualTargets.filter(target => !expected.has(target));
+
+  return { missing, unexpected };
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const publisher = args.get('publisher');
+  const extensionName = args.get('name');
+  const version = args.get('version');
+  const mode = args.get('mode') ?? 'universal';
+  const targets = (args.get('targets') ?? '')
+    .split(',')
+    .map(target => target.trim())
+    .filter(Boolean);
+  const timeoutSeconds = Number(args.get('timeout-seconds') ?? '900');
+  const pollSeconds = Number(args.get('poll-seconds') ?? '20');
+
+  if (!publisher || !extensionName || !version) {
+    throw new Error('Expected --publisher, --name, and --version.');
+  }
+
+  if (mode !== 'universal' && mode !== 'targeted') {
+    throw new Error(`Unsupported mode '${mode}'. Use 'universal' or 'targeted'.`);
+  }
+
+  if (mode === 'targeted' && targets.length === 0) {
+    throw new Error('Expected --targets when --mode targeted is used.');
+  }
+
+  const extensionId = `${publisher}.${extensionName}`;
+  const deadline = Date.now() + timeoutSeconds * 1000;
+  let lastPublishedVersion = '';
+
+  while (Date.now() <= deadline) {
+    const extension = await showExtension(extensionId);
+    const latestVersion = extension.versions?.[0]?.version ?? '';
+    lastPublishedVersion = latestVersion;
+
+    if (latestVersion !== version) {
+      console.log(
+        `Marketplace still shows '${latestVersion || 'unknown'}'; waiting for '${version}'.`,
+      );
+      await sleep(pollSeconds * 1000);
+      continue;
+    }
+
+    const publishedTargets = normalizeTargets(extension.versions ?? [], version);
+
+    if (mode === 'universal') {
+      if (publishedTargets.length > 0) {
+        throw new Error(
+          `Expected universal publish for ${extensionId}@${version}, but Marketplace advertises targets: ${publishedTargets.join(', ')}`,
+        );
+      }
+    } else {
+      const { missing, unexpected } = compareTargets(publishedTargets, targets);
+      if (missing.length > 0 || unexpected.length > 0) {
+        throw new Error(
+          `Marketplace targets mismatch for ${extensionId}@${version}. Missing: ${missing.join(', ') || 'none'}. Unexpected: ${unexpected.join(', ') || 'none'}.`,
+        );
+      }
+    }
+
+    const packageUrl = `https://marketplace.visualstudio.com/_apis/public/gallery/publishers/${publisher}/vsextensions/${extensionName}/${version}/vspackage`;
+    const packageResponse = await fetchPackage(packageUrl);
+    const contentType = packageResponse.headers.get('content-type') ?? '';
+
+    if (!packageResponse.ok) {
+      throw new Error(
+        `Marketplace package download failed for ${extensionId}@${version}: HTTP ${packageResponse.status}`,
+      );
+    }
+
+    if (!contentType.includes('application/vsix')) {
+      throw new Error(
+        `Marketplace package download returned unexpected content type '${contentType}' for ${extensionId}@${version}.`,
+      );
+    }
+
+    console.log(
+      `Marketplace release verified for ${extensionId}@${version} (${mode}, universal vspackage reachable).`,
+    );
+    return;
+  }
+
+  throw new Error(
+    `Marketplace did not expose expected version '${version}' for ${extensionId} before timeout. Last visible version: '${lastPublishedVersion || 'unknown'}'.`,
+  );
+}
+
+main().catch(error => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});

scripts/verify-marketplace-release.mjs

@@ -126,7 +126,9 @@ describe("activateHomeguardExtension", () => {
       { folderPath: homeDir, action: "redirected" }
     ]);
     expect(removedFolders).toEqual([homeDir]);
-    expect(openedFolders).toEqual([escapeDir]);
+    expect(openedFolders.map((entry) => path.normalize(entry))).toEqual([
+      path.normalize(escapeDir)
+    ]);
     expect(infos[0]).toContain("redirected");
 
     const readme = await readFile(path.join(escapeDir, "README.md"), "utf8");
@@ -232,7 +234,9 @@ describe("createHomeguardCommandHandlers", () => {
 
     const target = await handlers.openEscapeFolder();
 
-    expect(target).toBe(path.join(homeDir, "work", "_escape"));
-    expect(openedFolders).toEqual([path.join(homeDir, "work", "_escape")]);
+    expect(path.normalize(target)).toBe(path.normalize(path.join(homeDir, "work", "_escape")));
+    expect(openedFolders.map((entry) => path.normalize(entry))).toEqual([
+      path.normalize(path.join(homeDir, "work", "_escape"))
+    ]);
   });
 });

tests/homeguardExtension.test.ts

@@ -277,7 +277,9 @@ describe("createWorkspaceSafetyGuard", () => {
     expect(result.disposition).toBe("blocked");
     expect(result.result).toBeUndefined();
     expect(removedFolders).toEqual([homeDir]);
-    expect(openedFolders).toEqual([path.join(homeDir, "work", "_escape")]);
+    expect(openedFolders.map((entry) => path.normalize(entry))).toEqual([
+      path.normalize(path.join(homeDir, "work", "_escape"))
+    ]);
   });
 
   it("cancels git operations when the user declines confirmation", async () => {
@@ -297,4 +299,4 @@ describe("createWorkspaceSafetyGuard", () => {
     expect(result.allowed).toBe(false);
     expect(result.disposition).toBe("cancelled");
   });
-});
+});