@serviceme/devtools-core 0.2.0 → 0.3.0

package/dist/index.js

@@ -75,7 +75,6 @@ __export(src_exports, {
   MIGRATION_FAILURES_FILENAME: () => MIGRATION_FAILURES_FILENAME,
   MicrosoftAuthProvider: () => MicrosoftAuthProvider,
   MicrosoftProviderNotHostedError: () => MicrosoftProviderNotHostedError,
-  MigrateToGlobal: () => MigrateToGlobal,
   NodeGitSpawner: () => NodeGitSpawner,
   PROFILES_JSON_FILENAME: () => PROFILES_JSON_FILENAME,
   PidManager: () => PidManager,
@@ -174,6 +173,7 @@ __export(src_exports, {
   isUserRepo: () => isUserRepo,
   matchesCron: () => matchesCron,
   mergeWithDefaults: () => mergeWithDefaults,
+  migrateToGlobal: () => migrateToGlobal,
   moveFiles: () => moveFiles,
   narrowRepoConfig: () => narrowRepoConfig,
   noopLogger: () => noopLogger,
@@ -1035,6 +1035,11 @@ var DEFAULT_DEVICE_CODE_URL = "https://github.com/login/device/code";
 var DEFAULT_TOKEN_URL = "https://github.com/login/oauth/access_token";
 var DEFAULT_USER_URL = "https://api.github.com/user";
 var DEFAULT_SCOPE = "read:user user:email";
+var DEVICE_CODE_MAX_ATTEMPTS = 3;
+var DEFAULT_DEVICE_CODE_RETRY_BASE_DELAY_MS = 500;
+function isTransientNetworkError(error) {
+  return error instanceof TypeError;
+}
 var GitHubAuthProvider = class {
   constructor(config) {
     this.providerId = "github";
@@ -1050,7 +1055,8 @@ var GitHubAuthProvider = class {
       minPollIntervalMs: config.minPollIntervalMs ?? 1e3,
       maxPollIntervalMs: config.maxPollIntervalMs ?? 15e3,
       maxWaitMs: config.maxWaitMs,
-      fetchImpl: config.fetchImpl ?? fetch
+      fetchImpl: config.fetchImpl ?? fetch,
+      deviceCodeRetryBaseDelayMs: config.deviceCodeRetryBaseDelayMs ?? DEFAULT_DEVICE_CODE_RETRY_BASE_DELAY_MS
     };
   }
   async requestDeviceFlow(opts) {
@@ -1058,29 +1064,43 @@ var GitHubAuthProvider = class {
       client_id: this.cfg.clientId,
       scope: opts?.scope ?? this.cfg.scope
     });
-    const resp = await this.cfg.fetchImpl(this.cfg.deviceCodeUrl, {
-      method: "POST",
-      headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
-        "User-Agent": "serviceme-core"
-      },
-      body
-    });
-    if (!resp.ok) {
-      throw new Error(`GitHub device-code request failed: HTTP ${resp.status}`);
-    }
-    const data = await resp.json();
-    if (!data.device_code || !data.user_code || !data.verification_uri) {
-      throw new Error("GitHub device-code response missing required fields");
+    let lastNetworkError;
+    for (let attempt = 1; attempt <= DEVICE_CODE_MAX_ATTEMPTS; attempt++) {
+      let resp;
+      try {
+        resp = await this.cfg.fetchImpl(this.cfg.deviceCodeUrl, {
+          method: "POST",
+          headers: {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": "serviceme-core"
+          },
+          body
+        });
+      } catch (error) {
+        if (!isTransientNetworkError(error) || attempt === DEVICE_CODE_MAX_ATTEMPTS) {
+          throw error;
+        }
+        lastNetworkError = error;
+        await sleep(this.cfg.deviceCodeRetryBaseDelayMs * 2 ** (attempt - 1));
+        continue;
+      }
+      if (!resp.ok) {
+        throw new Error(`GitHub device-code request failed: HTTP ${resp.status}`);
+      }
+      const data = await resp.json();
+      if (!data.device_code || !data.user_code || !data.verification_uri) {
+        throw new Error("GitHub device-code response missing required fields");
+      }
+      return {
+        provider: this.providerId,
+        userCode: data.user_code,
+        verificationUrl: data.verification_uri,
+        expiresAt: Date.now() + data.expires_in * 1e3,
+        message: `Open ${data.verification_uri} and enter ${data.user_code}`
+      };
     }
-    return {
-      provider: this.providerId,
-      userCode: data.user_code,
-      verificationUrl: data.verification_uri,
-      expiresAt: Date.now() + data.expires_in * 1e3,
-      message: `Open ${data.verification_uri} and enter ${data.user_code}`
-    };
+    throw lastNetworkError ?? new Error("GitHub device-code request failed");
   }
   async completeDeviceFlow(deviceCode, shouldContinue) {
     const start = Date.now();
@@ -1098,19 +1118,28 @@ var GitHubAuthProvider = class {
       if (shouldContinue && !shouldContinue()) {
         throw new Error("GitHub device flow cancelled by caller");
       }
-      const resp = await this.cfg.fetchImpl(this.cfg.tokenUrl, {
-        method: "POST",
-        headers: {
-          Accept: "application/json",
-          "Content-Type": "application/json",
-          "User-Agent": "serviceme-core"
-        },
-        body: JSON.stringify({
-          client_id: this.cfg.clientId,
-          device_code: deviceCode,
-          grant_type: "urn:ietf:params:oauth:grant-type:device_code"
-        })
-      });
+      let resp;
+      try {
+        resp = await this.cfg.fetchImpl(this.cfg.tokenUrl, {
+          method: "POST",
+          headers: {
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            "User-Agent": "serviceme-core"
+          },
+          body: JSON.stringify({
+            client_id: this.cfg.clientId,
+            device_code: deviceCode,
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+          })
+        });
+      } catch (error) {
+        if (!isTransientNetworkError(error)) {
+          throw error;
+        }
+        pollIntervalMs = Math.min(Math.round(pollIntervalMs * 1.5), this.cfg.maxPollIntervalMs);
+        continue;
+      }
       if (!resp.ok) {
         pollIntervalMs = Math.min(Math.round(pollIntervalMs * 1.5), this.cfg.maxPollIntervalMs);
         continue;
@@ -2284,14 +2313,7 @@ function extractFrontmatter(raw) {
   }
   return { data, body };
 }
-var SKIP_DIRS = /* @__PURE__ */ new Set([
-  ".git",
-  "node_modules",
-  ".vscode",
-  "dist",
-  "build",
-  "out"
-]);
+var SKIP_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", ".vscode", "dist", "build", "out"]);
 var SKIP_TOP_LEVEL_SCAN_DIRS = /* @__PURE__ */ new Set([...SKIP_DIRS, "plugins"]);
 
 // src/drafts/index.ts
@@ -2708,54 +2730,82 @@ var GitClient = class {
    * Rewrite an upstream URL to its proxy form.
    *
    * Examples:
-   *   rewriteRemoteUrl("medalsoftchina-ms-skills",
+   *   rewriteRemoteUrl("repo-aHR0cHM6Ly9naXRodWIuY29tL21lZGFsc29mdGNoaW5hL21zLXNraWxscy5naXQ",
    *     "https://github.com/medalsoftchina/ms-skills.git")
-   *     → "http://localhost:3000/git-proxy/medalsoftchina-ms-skills"
+   *     → "http://localhost:3000/git-proxy/repo-aHR0cHM6Ly9naXRodWIuY29tL21lZGFsc29mdGNoaW5hL21zLXNraWxscy5naXQ"
    *
-   *   rewriteRemoteUrl("my-team-internal",
+   *   rewriteRemoteUrl("repo-aHR0cHM6Ly9naXRodWIuY29tL3RlYW0vaW50ZXJuYWwuZ2l0",
    *     "git@github.com:medalsoftchina/ms-skills.git")
-   *     → "http://localhost:3000/git-proxy/my-team-internal"
+   *     → "http://localhost:3000/git-proxy/repo-aHR0cHM6Ly9naXRodWIuY29tL3RlYW0vaW50ZXJuYWwuZ2l0"
    *
    * The original URL's host/owner is intentionally DROPPED — the proxy
    * knows the upstream from the per-repo config, not from the URL. This
-   * means callers can't accidentally route a user-repo URL through the
-   * default-repo proxy slot.
+   * means callers can route both default and user repos through the same
+   * dynamic proxy-id scheme.
    */
-  rewriteRemoteUrl(_repoId, _originalUrl) {
+  rewriteRemoteUrl(_repoId, originalUrl, useProxy = true) {
+    if (!useProxy) {
+      return originalUrl;
+    }
     return `${this.serverProxyBase}/${_repoId}`;
   }
   /**
    * `git clone <proxyUrl> <localPath>` — initialize a new local repo
    * from the proxy. Returns when the clone succeeds; throws on failure.
+   *
+   * When `branch` is provided, the clone is restricted to that branch
+   * via `git clone -b <branch> -- <proxyUrl> <localPath>` so the local
+   * checkout lands on the configured `repo.branch` instead of the
+   * upstream default branch. The parameter is optional and backward
+   * compatible — omitting it keeps the original behaviour.
    */
-  async clone(repoId, originalUrl, localPath) {
-    const proxyUrl = this.rewriteRemoteUrl(repoId, originalUrl);
-    const args = ["clone", "--", proxyUrl, localPath];
+  async clone(repoId, originalUrl, localPath, branch, useProxy = true) {
+    const proxyUrl = this.rewriteRemoteUrl(repoId, originalUrl, useProxy);
+    const args = branch ? ["clone", "-b", branch, "--", proxyUrl, localPath] : ["clone", "--", proxyUrl, localPath];
     await this.runOrThrow(args, { cwd: process.cwd() });
   }
   /**
    * `git fetch <remote> <branch>` + return the resulting commit SHA.
    * Operates on an already-cloned repo at `localPath`.
+   *
+   * When `branch` is provided, the pull target is forced to that branch:
+   * if the local working tree is on a different branch, `git checkout
+   * <branch>` is issued first (git auto-tracks `origin/<branch>`), so
+   * the sync leaves the repo parked on the configured `repo.branch`.
+   * When `branch` is omitted the legacy behaviour is preserved — the
+   * current local branch is fast-forwarded. The parameter is optional
+   * and backward compatible.
    */
-  async pull(repoId, localPath) {
+  async pull(repoId, localPath, branch, useProxy = true, originalUrl) {
     const remoteUrl = await this.getRemoteUrl(localPath, "origin");
     if (!remoteUrl) {
       throw new Error(`no 'origin' remote configured at ${localPath}`);
     }
-    const proxyUrl = this.rewriteRemoteUrl(repoId, remoteUrl);
+    const targetUrl = useProxy ? remoteUrl : originalUrl ?? remoteUrl;
+    const proxyUrl = this.rewriteRemoteUrl(repoId, targetUrl, useProxy);
     await this.runOrThrow(["remote", "set-url", "origin", proxyUrl], { cwd: localPath });
     const before = await this.safeRevParse(localPath);
     await this.runOrThrow(["fetch", "origin"], { cwd: localPath });
     const after = await this.safeRevParse(localPath);
-    const branch = await this.currentBranch(localPath);
-    if (!branch) {
+    let targetBranch = branch;
+    if (!targetBranch) {
+      targetBranch = await this.currentBranch(localPath);
+    } else {
+      const current = await this.currentBranch(localPath);
+      if (current !== targetBranch) {
+        await this.runOrThrow(["checkout", targetBranch], { cwd: localPath });
+      }
+    }
+    if (!targetBranch) {
       throw new Error(`could not determine current branch at ${localPath}`);
     }
-    await this.runOrThrow(["merge", "--ff-only", `origin/${branch}`], { cwd: localPath });
+    await this.runOrThrow(["merge", "--ff-only", `origin/${targetBranch}`], {
+      cwd: localPath
+    });
     return {
       updated: before !== after,
       commitSha: after,
-      branch
+      branch: targetBranch
     };
   }
   /**
@@ -2763,12 +2813,12 @@ var GitClient = class {
    * for committing locally first. The server's GitProxy injects the
    * PAT on the way upstream.
    */
-  async push(repoId, localPath, branch) {
+  async push(repoId, localPath, branch, useProxy = true) {
     const remoteUrl = await this.getRemoteUrl(localPath, "origin");
     if (!remoteUrl) {
       throw new Error(`no 'origin' remote configured at ${localPath}`);
     }
-    const proxyUrl = this.rewriteRemoteUrl(repoId, remoteUrl);
+    const proxyUrl = this.rewriteRemoteUrl(repoId, remoteUrl, useProxy);
     await this.runOrThrow(["remote", "set-url", "origin", proxyUrl], { cwd: localPath });
     const result = await this.spawner.spawn(
       ["push", "origin", `refs/heads/${branch}:refs/heads/${branch}`],
@@ -2788,8 +2838,8 @@ var GitClient = class {
    * `git ls-remote <proxyUrl>` — list advertised branches without
    * cloning. Used by addUserRepo to detect the default branch.
    */
-  async lsRemote(repoId, originalUrl) {
-    const proxyUrl = this.rewriteRemoteUrl(repoId, originalUrl);
+  async lsRemote(repoId, originalUrl, useProxy = true) {
+    const proxyUrl = this.rewriteRemoteUrl(repoId, originalUrl, useProxy);
     const result = await this.spawner.spawn(["ls-remote", "--heads", "--", proxyUrl], {
       cwd: process.cwd()
     });
@@ -3548,14 +3598,36 @@ function isUserRepo(repo) {
 
 // src/repo-manager/index.ts
 function idFromUrl(url) {
-  const trimmed = url.trim().replace(/\.git$/, "");
-  const last = trimmed.split("/").pop() ?? "";
-  const safe = last.replace(/[^a-zA-Z0-9_-]/g, "-").toLowerCase();
+  const trimmed = url.trim().replace(/\/+$/, "").replace(/\.git$/, "");
+  const sanitize = (value) => value.trim().toLowerCase().replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+  let owner = "";
+  let repo = "";
+  if (/^https?:\/\//i.test(trimmed)) {
+    const parsed = new URL(trimmed);
+    const segments = parsed.pathname.split("/").filter(Boolean);
+    repo = segments.at(-1) ?? "";
+    owner = segments.length >= 2 ? segments.at(-2) ?? "" : "";
+  } else if (trimmed.startsWith("git@")) {
+    const colon = trimmed.indexOf(":");
+    const repoPath = colon >= 0 ? trimmed.slice(colon + 1) : "";
+    const segments = repoPath.split("/").filter(Boolean);
+    repo = segments.at(-1) ?? "";
+    owner = segments.length >= 2 ? segments.at(-2) ?? "" : "";
+  } else {
+    repo = trimmed.split("/").pop() ?? "";
+  }
+  const safeRepo = sanitize(repo);
+  const safeOwner = sanitize(owner);
+  const safe = safeOwner ? `${safeOwner}-${safeRepo}` : safeRepo;
   if (!SAFE_REPO_ID_PATTERN.test(safe)) {
     throw new InvalidRepoUrlError(`cannot derive a valid repo id from url: ${url}`);
   }
   return safe;
 }
+function proxyRepoId(url) {
+  const encoded = Buffer.from(url.trim(), "utf8").toString("base64url");
+  return `repo-${encoded}`;
+}
 var RepoManagerError = class extends Error {
   constructor(message) {
     super(message);
@@ -3584,7 +3656,7 @@ var RepoManager = class {
    * but do NOT abort the loop — the UI surfaces per-repo state and the
    * user can retry.
    *
-   * Per spec §3.1: 4 default repos; the loop honors `enabled=false` and
+   * Per spec §3.1: iterate all default repos; the loop honors `enabled=false` and
    * disables (rather than removes) repos the user has turned off.
    */
   async ensureDefaults() {
@@ -3594,11 +3666,14 @@ var RepoManager = class {
       if (!repo.enabled) continue;
       const localPath = getRepoDir(repo.id);
       const exists = await this.pathExists(localPath);
-      if (exists) continue;
+      if (exists) {
+        if (await this.isValidGitRepo(localPath)) continue;
+        await fs8.rm(localPath, { recursive: true, force: true });
+      }
       try {
         if (!this.skipClone) {
           await fs8.mkdir(path11.dirname(localPath), { recursive: true });
-          await this.git.clone(repo.id, repo.url, localPath);
+          await this.git.clone(repo.id, repo.url, localPath, repo.branch, true);
         }
         await this.store.updateRepo(repo.id, {
           lastSyncStatus: "ok",
@@ -3627,12 +3702,17 @@ var RepoManager = class {
   async pullOne(repoId) {
     const repo = this.store.get(repoId);
     if (!repo) throw new RepoNotInStoreError(repoId);
+    const useProxy = repo.useProxy ?? true;
+    const proxyId = useProxy ? proxyRepoId(repo.url) : repo.id;
     const localPath = getRepoDir(repoId);
     const exists = await this.pathExists(localPath);
-    if (!exists) {
+    if (exists && !await this.isValidGitRepo(localPath)) {
+      await fs8.rm(localPath, { recursive: true, force: true });
+    }
+    if (!exists || !await this.pathExists(localPath)) {
       await fs8.mkdir(path11.dirname(localPath), { recursive: true });
       if (!this.skipClone) {
-        await this.git.clone(repoId, repo.url, localPath);
+        await this.git.clone(proxyId, repo.url, localPath, repo.branch, useProxy);
       }
       const result = {
         updated: true,
@@ -3646,7 +3726,7 @@ var RepoManager = class {
       return result;
     }
     try {
-      const result = await this.git.pull(repoId, localPath);
+      const result = await this.git.pull(proxyId, localPath, repo.branch, useProxy, repo.url);
       await this.store.updateRepo(repoId, {
         lastSyncStatus: "ok",
         lastSyncAt: this.now(),
@@ -3698,10 +3778,12 @@ var RepoManager = class {
       throw new InvalidRepoUrlError(`expected https:// or git@ URL, got: ${url}`);
     }
     const id = idFromUrl(url);
+    const useProxy = input.useProxy ?? true;
+    const userProxyId = useProxy ? proxyRepoId(url) : id;
     assertSafeRepoId(id);
     let branch = input.branch?.trim();
     if (!branch) {
-      const branches = await this.git.lsRemote(id, url);
+      const branches = await this.git.lsRemote(userProxyId, url, useProxy);
       const head = branches.find((b) => b.ref === "refs/heads/main") ?? branches.find((b) => b.ref === "refs/heads/master") ?? branches.find((b) => b.ref.endsWith("/v2"));
       if (!head) {
         throw new InvalidRepoUrlError(
@@ -3719,6 +3801,7 @@ var RepoManager = class {
       url,
       branch,
       enabled: true,
+      useProxy,
       writeEnabled: false,
       source: "user",
       addedAt: this.now()
@@ -3728,7 +3811,7 @@ var RepoManager = class {
     if (!this.skipClone) {
       const localPath = getRepoDir(id);
       await fs8.mkdir(path11.dirname(localPath), { recursive: true });
-      await this.git.clone(id, url, localPath);
+      await this.git.clone(userProxyId, url, localPath, branch, useProxy);
       cloned = true;
     }
     return { repo, branch, cloned };
@@ -3777,6 +3860,14 @@ var RepoManager = class {
   async ensureHome() {
     await fs8.mkdir(getServicemeHome(), { recursive: true });
   }
+  /**
+   * Returns `true` when `p` contains a `.git` entry — i.e. it is an
+   * initialised git repository and safe to `pull`. Empty directories
+   * (e.g. from an interrupted clone) return `false`.
+   */
+  async isValidGitRepo(p) {
+    return this.pathExists(path11.join(p, ".git"));
+  }
   async pathExists(p) {
     try {
       await fs8.stat(p);
@@ -3793,10 +3884,11 @@ var FIXED_ADDED_AT = "2026-06-29T00:00:00.000Z";
 var DEFAULT_REPO_SEEDS = [
   {
     id: "medalsoftchina-ms-skills",
-    name: "MS DevTools Skills (\u7CBE\u9009)",
+    name: "SERVICEME (\u7CBE\u9009)",
     url: "https://github.com/medalsoftchina/ms-skills.git",
     branch: "v2",
     enabled: true,
+    useProxy: true,
     writeEnabled: true,
     source: "default",
     description: "Medalsoft \u7CBE\u9009 skill/agent \u4ED3\u5E93\uFF0C\u53EF\u8BFB\u53EF\u5199"
@@ -3807,6 +3899,7 @@ var DEFAULT_REPO_SEEDS = [
     url: "https://github.com/anthropics/skills.git",
     branch: "main",
     enabled: true,
+    useProxy: true,
     writeEnabled: false,
     source: "default",
     description: "Anthropic \u5B98\u65B9 skills \u793A\u4F8B"
@@ -3817,16 +3910,29 @@ var DEFAULT_REPO_SEEDS = [
     url: "https://github.com/github/awesome-copilot.git",
     branch: "main",
     enabled: true,
+    useProxy: true,
     writeEnabled: false,
     source: "default",
     description: "GitHub Copilot \u793E\u533A\u7CBE\u9009 prompts/agents"
   },
+  {
+    id: "mattpocock-skills",
+    name: "Matt Pocock Skills",
+    url: "https://github.com/mattpocock/skills.git",
+    branch: "main",
+    enabled: true,
+    useProxy: true,
+    writeEnabled: false,
+    source: "default",
+    description: "Matt Pocock \u793E\u533A skills \u4ED3\u5E93"
+  },
   {
     id: "composiohq-awesome-claude-skills",
     name: "Composio Awesome Claude Skills",
     url: "https://github.com/ComposioHQ/awesome-claude-skills.git",
     branch: "main",
     enabled: true,
+    useProxy: true,
     writeEnabled: false,
     source: "default",
     description: "Composio \u7EF4\u62A4\u7684 Claude skills \u96C6\u5408"
@@ -3903,6 +4009,7 @@ var baseRepoFields = {
   url: import_zod.z.string().url(),
   branch: import_zod.z.string().min(1).max(200),
   enabled: import_zod.z.boolean(),
+  useProxy: import_zod.z.boolean().optional().default(true),
   writeEnabled: import_zod.z.boolean(),
   addedAt: isoTimestampSchema,
   lastSyncAt: isoTimestampSchema.optional(),
@@ -5949,7 +6056,10 @@ function readV1Config(v1Path) {
   try {
     raw = fs19.readFileSync(v1Path, "utf-8");
   } catch (err) {
-    return { ok: false, error: `read failed: ${err instanceof Error ? err.message : String(err)}` };
+    return {
+      ok: false,
+      error: `read failed: ${err instanceof Error ? err.message : String(err)}`
+    };
   }
   let parsed;
   try {
@@ -6004,79 +6114,77 @@ function disambiguateName(task, existingNames, workspaceName) {
   existingNames.add(candidate);
   return { ...task, name: candidate };
 }
-var MigrateToGlobal = class {
-  /**
-   * Run the migration. Idempotent: each v1 file is deleted after processing,
-   * so re-running this method on a partially-migrated state is safe (the
-   * already-migrated files no longer exist; only the remainder is processed).
-   */
-  static async run(options) {
-    const globalConfigPath = options.globalConfigPath ?? getScheduledTasksConfigPath();
-    const migrationFailuresPath = options.migrationFailuresPath ?? getMigrationFailuresPath();
-    const probe = options.probe ?? defaultProbe;
-    const existing = readJsonFile(globalConfigPath);
-    const baseConfig = existing && existing.version === 2 ? existing : { version: 2, tasks: [] };
-    const existingNames = new Set(baseConfig.tasks.map((t) => t.name));
-    const priorFailures = readJsonFile(migrationFailuresPath) ?? [];
-    const failures = [...priorFailures];
-    let migrated = 0;
-    const conflicts = [];
-    const issues = [];
-    for (const workspacePath of options.workspacePaths) {
-      const v1Path = path20.join(workspacePath, WORKSPACE_DIR, V1_FILENAME);
-      if (!fs19.existsSync(v1Path)) continue;
-      const v1 = readV1Config(v1Path);
-      if (!v1.ok) {
-        failures.push({
-          workspacePath,
-          v1Path,
-          error: v1.error,
-          at: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        safeDelete(v1Path);
-        continue;
-      }
-      let workspaceRef;
-      try {
-        workspaceRef = await probe(workspacePath);
-      } catch (err) {
-        failures.push({
-          workspacePath,
-          v1Path,
-          error: `probe failed: ${err instanceof Error ? err.message : String(err)}`,
-          at: (/* @__PURE__ */ new Date()).toISOString()
-        });
-        safeDelete(v1Path);
-        continue;
-      }
-      const { config, issues: taskIssues } = (0, import_devtools_protocol9.migrateV1ToV2)(v1.config, workspaceRef);
-      issues.push(...taskIssues);
-      const newTasks = config.tasks.map((t) => {
-        if (existingNames.has(t.name)) {
-          conflicts.push(t.name);
-          return disambiguateName(t, existingNames, workspaceRef.name);
-        }
-        existingNames.add(t.name);
-        return t;
+async function migrateToGlobal(options) {
+  const globalConfigPath = options.globalConfigPath ?? getScheduledTasksConfigPath();
+  const migrationFailuresPath = options.migrationFailuresPath ?? getMigrationFailuresPath();
+  const probe = options.probe ?? defaultProbe;
+  const existing = readJsonFile(globalConfigPath);
+  const baseConfig = existing && existing.version === 2 ? existing : { version: 2, tasks: [] };
+  const existingNames = new Set(baseConfig.tasks.map((t) => t.name));
+  const priorFailures = readJsonFile(migrationFailuresPath) ?? [];
+  const failures = [...priorFailures];
+  let migrated = 0;
+  const conflicts = [];
+  const issues = [];
+  for (const workspacePath of options.workspacePaths) {
+    const v1Path = path20.join(workspacePath, WORKSPACE_DIR, V1_FILENAME);
+    if (!fs19.existsSync(v1Path)) continue;
+    const v1 = readV1Config(v1Path);
+    if (!v1.ok) {
+      failures.push({
+        workspacePath,
+        v1Path,
+        error: v1.error,
+        at: (/* @__PURE__ */ new Date()).toISOString()
       });
-      baseConfig.tasks.push(...newTasks);
-      migrated += 1;
       safeDelete(v1Path);
+      continue;
     }
-    if (migrated > 0) {
-      ensureDir(globalConfigPath);
-      const tmp = `${globalConfigPath}.tmp`;
-      fs19.writeFileSync(tmp, JSON.stringify(baseConfig, null, "	"), "utf-8");
-      fs19.renameSync(tmp, globalConfigPath);
-    }
-    if (failures.length > priorFailures.length) {
-      writeJsonFile(migrationFailuresPath, failures);
-    } else if (failures.length === 0 && priorFailures.length > 0) {
-      safeDelete(migrationFailuresPath);
+    let workspaceRef;
+    try {
+      workspaceRef = await probe(workspacePath);
+    } catch (err) {
+      failures.push({
+        workspacePath,
+        v1Path,
+        error: `probe failed: ${err instanceof Error ? err.message : String(err)}`,
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      });
+      safeDelete(v1Path);
+      continue;
     }
-    return { migrated, failed: failures.length - priorFailures.length, conflicts, issues };
+    const { config, issues: taskIssues } = (0, import_devtools_protocol9.migrateV1ToV2)(v1.config, workspaceRef);
+    issues.push(...taskIssues);
+    const newTasks = config.tasks.map((t) => {
+      if (existingNames.has(t.name)) {
+        conflicts.push(t.name);
+        return disambiguateName(t, existingNames, workspaceRef.name);
+      }
+      existingNames.add(t.name);
+      return t;
+    });
+    baseConfig.tasks.push(...newTasks);
+    migrated += 1;
+    safeDelete(v1Path);
   }
-};
+  if (migrated > 0) {
+    ensureDir(globalConfigPath);
+    const tmp = `${globalConfigPath}.tmp`;
+    fs19.writeFileSync(tmp, JSON.stringify(baseConfig, null, "	"), "utf-8");
+    fs19.renameSync(tmp, globalConfigPath);
+  }
+  if (failures.length > priorFailures.length) {
+    writeJsonFile(migrationFailuresPath, failures);
+  } else if (failures.length === 0 && priorFailures.length > 0) {
+    safeDelete(migrationFailuresPath);
+  }
+  return {
+    migrated,
+    failed: failures.length - priorFailures.length,
+    conflicts,
+    issues
+  };
+}
 
 // src/scheduled-tasks/workspace-probe/WorkspaceProbe.ts
 var import_node_child_process5 = require("child_process");
@@ -6979,7 +7087,6 @@ var ToolboxCore = class {
   MIGRATION_FAILURES_FILENAME,
   MicrosoftAuthProvider,
   MicrosoftProviderNotHostedError,
-  MigrateToGlobal,
   NodeGitSpawner,
   PROFILES_JSON_FILENAME,
   PidManager,
@@ -7078,6 +7185,7 @@ var ToolboxCore = class {
   isUserRepo,
   matchesCron,
   mergeWithDefaults,
+  migrateToGlobal,
   moveFiles,
   narrowRepoConfig,
   noopLogger,