@serviceme/devtools-core 0.2.1 → 0.3.0

package/dist/index.mjs

@@ -893,9 +893,7 @@ var GitHubAuthProvider = class {
         continue;
       }
       if (!resp.ok) {
-        throw new Error(
-          `GitHub device-code request failed: HTTP ${resp.status}`
-        );
+        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) {
@@ -946,17 +944,11 @@ var GitHubAuthProvider = class {
         if (!isTransientNetworkError(error)) {
           throw error;
         }
-        pollIntervalMs = Math.min(
-          Math.round(pollIntervalMs * 1.5),
-          this.cfg.maxPollIntervalMs
-        );
+        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
-        );
+        pollIntervalMs = Math.min(Math.round(pollIntervalMs * 1.5), this.cfg.maxPollIntervalMs);
         continue;
       }
       const data = await resp.json();
@@ -982,9 +974,7 @@ var GitHubAuthProvider = class {
       if (data.error === "slow_down") {
         consecutiveSlowDown++;
         pollIntervalMs = Math.min(
-          Math.round(
-            pollIntervalMs * 1.5 + Math.min(consecutiveSlowDown * 500, 2e3)
-          ),
+          Math.round(pollIntervalMs * 1.5 + Math.min(consecutiveSlowDown * 500, 2e3)),
           this.cfg.maxPollIntervalMs
         );
         continue;
@@ -1020,9 +1010,7 @@ var GitHubAuthProvider = class {
     }
     const data = await resp.json();
     if (!data.access_token) {
-      throw new Error(
-        `GitHub refresh failed: ${data.error ?? "no_access_token"}`
-      );
+      throw new Error(`GitHub refresh failed: ${data.error ?? "no_access_token"}`);
     }
     const rawUser = await this.fetchGitHubUser(data.access_token);
     const email = await this.resolveEmail(data.access_token, rawUser);
@@ -1092,16 +1080,13 @@ var GitHubAuthProvider = class {
    */
   async resolveEmail(token, user) {
     if (user.email) return user.email;
-    const emailsResp = await this.cfg.fetchImpl(
-      "https://api.github.com/user/emails",
-      {
-        headers: {
-          Accept: "application/vnd.github+json",
-          Authorization: `Bearer ${token}`,
-          "User-Agent": "serviceme-core"
-        }
+    const emailsResp = await this.cfg.fetchImpl("https://api.github.com/user/emails", {
+      headers: {
+        Accept: "application/vnd.github+json",
+        Authorization: `Bearer ${token}`,
+        "User-Agent": "serviceme-core"
       }
-    );
+    });
     if (!emailsResp.ok) {
       return null;
     }
@@ -2562,54 +2547,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
     };
   }
   /**
@@ -2617,12 +2630,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}`],
@@ -2642,8 +2655,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()
     });
@@ -3409,16 +3422,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}`
-    );
+    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);
@@ -3447,7 +3480,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() {
@@ -3464,7 +3497,7 @@ var RepoManager = class {
       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",
@@ -3493,6 +3526,8 @@ 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 && !await this.isValidGitRepo(localPath)) {
@@ -3501,7 +3536,7 @@ var RepoManager = class {
     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,
@@ -3515,7 +3550,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(),
@@ -3564,15 +3599,15 @@ var RepoManager = class {
   async addUserRepo(input) {
     const url = input.url.trim();
     if (!/^https?:\/\//.test(url) && !url.startsWith("git@")) {
-      throw new InvalidRepoUrlError(
-        `expected https:// or git@ URL, got: ${url}`
-      );
+      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(
@@ -3590,6 +3625,7 @@ var RepoManager = class {
       url,
       branch,
       enabled: true,
+      useProxy,
       writeEnabled: false,
       source: "user",
       addedAt: this.now()
@@ -3599,7 +3635,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 };
@@ -3672,10 +3708,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"
@@ -3686,6 +3723,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"
@@ -3696,16 +3734,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"
@@ -3782,6 +3833,7 @@ var baseRepoFields = {
   url: z.string().url(),
   branch: z.string().min(1).max(200),
   enabled: z.boolean(),
+  useProxy: z.boolean().optional().default(true),
   writeEnabled: z.boolean(),
   addedAt: isoTimestampSchema,
   lastSyncAt: isoTimestampSchema.optional(),