@arcships/morula-runtime 0.1.0-alpha.6 → 0.1.0-alpha.7

package/dist/index.js

@@ -729,7 +729,7 @@ var BUILD_ID, BUILD_CONTEXTS, BUILD_DEFAULT_CONTEXT;
 var init_build_env = __esm({
   "../morula-cli-core/dist/build-env.js"() {
     "use strict";
-    BUILD_ID = "20260917063948.nogit";
+    BUILD_ID = "20260917073516.nogit";
     BUILD_CONTEXTS = {
       "local": "http://localhost:8080/api",
       "test": "https://morula.basecastle.com/api",
@@ -3632,7 +3632,7 @@ init_dist2();
 init_dist2();
 
 // src/build-env.ts
-var BUILD_VERSION2 = "0.1.0-alpha.6";
+var BUILD_VERSION2 = "0.1.0-alpha.7";
 
 // src/commands/daemon.ts
 init_dist();
@@ -4605,24 +4605,49 @@ function buildGitlabSshRemote(repoFullName, baseUrl) {
     return `ssh://git@${host}:${url.port}/${repoFullName}.git`;
   return `git@${host}:${repoFullName}.git`;
 }
-function ensureRepo(workdir, tenantId, repo, env, remoteUrl) {
+function buildDaemonRepoUrl(repoFullName, baseUrl) {
+  if (!baseUrl)
+    return `https://github.com/${repoFullName}.git`;
+  const url = new URL(baseUrl);
+  const path = repoFullName.replace(/^\/+/, "");
+  return `${url.protocol}//${url.host}/${path}.git`;
+}
+function ensureRepo(workdir, tenantId, repo, env, remoteUrl, daemonRemoteUrl) {
   const repoDir = join11(workdir, tenantId, repo);
+  const fetchUrl = daemonRemoteUrl ?? remoteUrl ?? buildDaemonRepoUrl(repo);
   if (existsSync8(join11(repoDir, ".git"))) {
     if (remoteUrl)
       syncRemoteUrl(repoDir, remoteUrl, env);
     try {
-      execFileSync6("git", ["-C", repoDir, "fetch", "origin", "--prune"], { env, stdio: "pipe" });
-    } catch {
+      if (daemonRemoteUrl) {
+        execFileSync6(
+          "git",
+          ["-C", repoDir, "fetch", "--prune", fetchUrl, "+refs/heads/*:refs/remotes/origin/*"],
+          { env, stdio: "pipe" }
+        );
+      } else {
+        execFileSync6("git", ["-C", repoDir, "fetch", "origin", "--prune"], { env, stdio: "pipe" });
+      }
+    } catch (err) {
+      throw new Error(`REPO_SYNC_FAILED: \u62C9\u53D6\u4ED3\u5E93\u5931\u8D25 ${repo}: ${gitErrorText(err)}`);
     }
     return repoDir;
   }
   mkdirSync6(repoDir, { recursive: true });
-  execFileSync6("git", ["clone", "--filter=blob:none", remoteUrl ?? `https://github.com/${repo}`, repoDir], {
-    env,
-    stdio: "pipe"
-  });
+  try {
+    execFileSync6("git", ["clone", "--filter=blob:none", fetchUrl, repoDir], { env, stdio: "pipe" });
+  } catch (err) {
+    throw new Error(`REPO_SYNC_FAILED: \u514B\u9686\u4ED3\u5E93\u5931\u8D25 ${repo}: ${gitErrorText(err)}`);
+  }
+  if (remoteUrl && remoteUrl !== fetchUrl)
+    syncRemoteUrl(repoDir, remoteUrl, env);
   return repoDir;
 }
+function gitErrorText(err) {
+  const e = err;
+  const stderr = e?.stderr ? e.stderr.toString().trim() : "";
+  return stderr || e?.message || String(err);
+}
 function syncRemoteUrl(repoDir, remoteUrl, env) {
   try {
     const cur = execFileSync6("git", ["-C", repoDir, "remote", "get-url", "origin"], { env, stdio: "pipe" }).toString().trim();
@@ -6005,31 +6030,58 @@ function ownerOf(repoFullName) {
 function buildRepoCachePath(workdir, tenantId, repoFullName) {
   return join14(workdir, "repos", tenantId, ownerOf(repoFullName), repoFullName);
 }
-function openRepoCache(workdir, tenantId, repoFullName, env, remoteUrl) {
+function openRepoCache(workdir, tenantId, repoFullName, env, agentRemoteUrl, daemonRemoteUrl) {
   const repoCachePath = buildRepoCachePath(workdir, tenantId, repoFullName);
-  const url = remoteUrl ?? `https://github.com/${repoFullName}`;
+  const currentOrigin = () => {
+    if (!existsSync11(join14(repoCachePath, ".git")))
+      return null;
+    try {
+      return execFileSync7("git", ["-C", repoCachePath, "remote", "get-url", "origin"], { encoding: "utf8", env, stdio: "pipe" }).trim() || null;
+    } catch {
+      return null;
+    }
+  };
+  const fetchUrl = () => daemonRemoteUrl ?? currentOrigin() ?? agentRemoteUrl ?? `https://github.com/${repoFullName}.git`;
+  const originUrl = () => agentRemoteUrl ?? fetchUrl();
   return {
     repoCachePath,
     ensure() {
       if (existsSync11(join14(repoCachePath, ".git"))) {
-        if (url)
-          syncRemoteUrl(repoCachePath, url, env);
+        syncRemoteUrl(repoCachePath, originUrl(), env);
         return;
       }
       mkdirSync8(dirname6(repoCachePath), { recursive: true });
-      execFileSync7("git", ["clone", "--filter=blob:none", url, repoCachePath], {
-        env,
-        stdio: "pipe"
-      });
+      const cloneUrl = fetchUrl();
+      try {
+        execFileSync7("git", ["clone", "--filter=blob:none", cloneUrl, repoCachePath], { env, stdio: "pipe" });
+      } catch (err) {
+        throw new Error(`REPO_SYNC_FAILED: \u514B\u9686\u4ED3\u5E93\u5931\u8D25 ${repoFullName}: ${gitErrorText2(err)}`);
+      }
+      if (originUrl() !== cloneUrl)
+        syncRemoteUrl(repoCachePath, originUrl(), env);
     },
     fetch() {
       try {
-        execFileSync7("git", ["-C", repoCachePath, "fetch", "origin", "--prune"], { env, stdio: "pipe" });
-      } catch {
+        if (daemonRemoteUrl) {
+          execFileSync7(
+            "git",
+            ["-C", repoCachePath, "fetch", "--prune", daemonRemoteUrl, "+refs/heads/*:refs/remotes/origin/*"],
+            { env, stdio: "pipe" }
+          );
+        } else {
+          execFileSync7("git", ["-C", repoCachePath, "fetch", "origin", "--prune"], { env, stdio: "pipe" });
+        }
+      } catch (err) {
+        throw new Error(`REPO_SYNC_FAILED: \u62C9\u53D6\u4ED3\u5E93\u5931\u8D25 ${repoFullName}: ${gitErrorText2(err)}`);
       }
     }
   };
 }
+function gitErrorText2(err) {
+  const e = err;
+  const stderr = e?.stderr ? e.stderr.toString().trim() : "";
+  return stderr || e?.message || String(err);
+}
 
 // src/daemon/repo-checkout-service.ts
 import { createServer as createServer3 } from "node:http";
@@ -6195,13 +6247,13 @@ function sleepSync2(ms) {
 function backoffMs(baseMs, random = Math.random) {
   return Math.round(baseMs * (0.5 + random() * 0.5));
 }
-function gitErrorText(err) {
+function gitErrorText3(err) {
   const e = err;
   const stderr = e?.stderr ? e.stderr.toString() : "";
   return `${stderr}${stderr ? "\n" : ""}${e?.message ?? String(err)}`;
 }
 function isIndexLockConflict(err) {
-  const text = gitErrorText(err);
+  const text = gitErrorText3(err);
   return /index\.lock/i.test(text) || /另一个 git 进程|another git process/i.test(text);
 }
 function worktreeIndexLockPath(repoCachePath, worktreePath) {
@@ -6242,7 +6294,7 @@ function addWorktreeWithRetry(repoCachePath, worktreePath, ref, deps = {}) {
         throw err;
       if (attempt === WORKTREE_ADD_MAX_ATTEMPTS)
         break;
-      const lockPath = indexLockPathFromError(gitErrorText(err)) ?? worktreeIndexLockPath(repoCachePath, worktreePath);
+      const lockPath = indexLockPathFromError(gitErrorText3(err)) ?? worktreeIndexLockPath(repoCachePath, worktreePath);
       const released = waitForIndexLockRelease(lockPath, waitMs);
       const backoff = backoffMs(WORKTREE_ADD_BACKOFF_MS[attempt - 1]);
       console.warn(
@@ -6251,7 +6303,7 @@ function addWorktreeWithRetry(repoCachePath, worktreePath, ref, deps = {}) {
       sleepSync2(backoff);
     }
   }
-  throw new Error(`WORKTREE_ADD_FAILED: worktree add \u8FDE\u7EED ${WORKTREE_ADD_MAX_ATTEMPTS} \u6B21\u5931\u8D25\uFF08${gitErrorText(lastErr).trim()}\uFF09`);
+  throw new Error(`WORKTREE_ADD_FAILED: worktree add \u8FDE\u7EED ${WORKTREE_ADD_MAX_ATTEMPTS} \u6B21\u5931\u8D25\uFF08${gitErrorText3(lastErr).trim()}\uFF09`);
 }
 var FOREIGN_RESIDUE_MAX_ENTRIES = 64;
 var FOREIGN_RESIDUE_SCAN_LIMIT = 2e3;
@@ -6313,7 +6365,7 @@ function reportForeignResidue(worktreePath, forensics, cleaned) {
     console.warn(`[daemon] ${detail}`);
 }
 function prepareWorktree(input) {
-  const cache = openRepoCache(input.workdir, input.tenantId, input.repoFullName, input.env, input.remoteUrl);
+  const cache = openRepoCache(input.workdir, input.tenantId, input.repoFullName, input.env, input.remoteUrl, input.daemonRemoteUrl);
   cache.ensure();
   cache.fetch();
   const requestedBase = input.baseBranch?.trim();
@@ -6798,7 +6850,8 @@ var LocalRepoCheckoutService = class {
         this.opts.tenantId,
         repoFullName,
         env,
-        baseUrl ? buildGitlabSshRemote(repoFullName, baseUrl) : void 0
+        baseUrl ? buildGitlabSshRemote(repoFullName, baseUrl) : void 0,
+        baseUrl ? buildDaemonRepoUrl(repoFullName, baseUrl) : void 0
       );
       cache.ensure();
       cache.fetch();
@@ -6806,6 +6859,8 @@ var LocalRepoCheckoutService = class {
         repoCachePath: cache.repoCachePath,
         taskRoot: task.workdir,
         repoFullName,
+        baseBranch: serverRes.baseBranch,
+        ref: req.ref,
         env
       });
       const headSha = execFileSync9("git", ["-C", worktreePath, "rev-parse", "HEAD"], { encoding: "utf8", env, stdio: "pipe" }).trim();
@@ -6859,7 +6914,8 @@ var LocalRepoCheckoutService = class {
         this.opts.tenantId,
         repoFullName,
         env,
-        baseUrl ? buildGitlabSshRemote(repoFullName, baseUrl) : void 0
+        baseUrl ? buildGitlabSshRemote(repoFullName, baseUrl) : void 0,
+        baseUrl ? buildDaemonRepoUrl(repoFullName, baseUrl) : void 0
       );
       cache.ensure();
       cache.fetch();
@@ -6916,26 +6972,78 @@ function resolveRepoTargetDir(taskRoot, base) {
 }
 function materializeReadWorktree(input) {
   const worktreePath = resolveRepoTargetDir(input.taskRoot, `${safeRepoDirName(input.repoFullName)}${READ_ONLY_REPO_DIR_SUFFIX}`);
+  const targetRef = resolveReadRef(input.repoCachePath, input.env, input.ref, input.baseBranch);
   if (existsSync14(join17(worktreePath, ".git"))) {
-    execFileSync9("git", ["-C", worktreePath, "fetch", "origin", "--prune"], { env: input.env, stdio: "pipe" });
+    const current = currentBranchName(worktreePath);
+    if (current)
+      throw new Error(`READ_WORKTREE_DIRTY: \u53EA\u8BFB\u68C0\u51FA\u5DF2\u5207\u5230\u5206\u652F ${current}\uFF0C\u62D2\u7EDD\u81EA\u52A8\u66F4\u65B0\uFF08\u8BF7\u6E05\u7406\u8BE5\u76EE\u5F55\u540E\u91CD\u8BD5\uFF09`);
+    if (hasLocalChanges2(worktreePath, input.env))
+      throw new Error("READ_WORKTREE_DIRTY: \u53EA\u8BFB\u68C0\u51FA\u5B58\u5728\u672A\u63D0\u4EA4\u6539\u52A8\uFF0C\u62D2\u7EDD\u81EA\u52A8\u66F4\u65B0\uFF08\u8BF7\u6E05\u7406\u8BE5\u76EE\u5F55\u540E\u91CD\u8BD5\uFF09");
+    execFileSync9("git", ["-C", worktreePath, "checkout", "--detach", targetRef], { env: input.env, stdio: "pipe" });
   } else {
     mkdirSync10(join17(worktreePath, ".."), { recursive: true });
-    execFileSync9("git", ["-C", input.repoCachePath, "worktree", "add", "--detach", worktreePath, resolveBaseRef(input.repoCachePath, input.env)], {
+    execFileSync9("git", ["-C", input.repoCachePath, "worktree", "add", "--detach", worktreePath, targetRef], {
       env: input.env,
       stdio: "pipe"
     });
   }
   return worktreePath;
 }
-function resolveBaseRef(repoCachePath, env) {
-  for (const ref of ["origin/main", "origin/master", "HEAD"]) {
-    try {
-      execFileSync9("git", ["-C", repoCachePath, "rev-parse", "--verify", ref], { env, stdio: "pipe" });
+function resolveReadRef(repoCachePath, env, requestedRef, baseBranch) {
+  const requested = requestedRef?.trim();
+  if (requested) {
+    const candidates = requested.startsWith("refs/") ? [requested] : [`origin/${requested}`, requested];
+    for (const ref of candidates) {
+      if (refExists(repoCachePath, ref, env))
+        return ref;
+    }
+    throw new Error(`REF_NOT_FOUND: repo cache \u65E0\u53EF\u7528\u5F15\u7528 ${requested}`);
+  }
+  const explicitBase = baseBranch?.trim();
+  if (explicitBase) {
+    const ref = `origin/${explicitBase}`;
+    if (refExists(repoCachePath, ref, env))
       return ref;
+    throw new Error(`BASE_REF_NOT_FOUND: repo cache \u65E0\u9ED8\u8BA4\u5206\u652F ${explicitBase}`);
+  }
+  const remoteHead = (() => {
+    try {
+      const out = execFileSync9("git", ["-C", repoCachePath, "symbolic-ref", "refs/remotes/origin/HEAD"], { encoding: "utf8", env, stdio: "pipe" }).trim();
+      return out.replace(/^refs\/remotes\//, "");
     } catch {
+      return null;
     }
+  })();
+  for (const ref of [remoteHead, "origin/main", "origin/master"]) {
+    if (!ref || !refExists(repoCachePath, ref, env))
+      continue;
+    return ref;
+  }
+  throw new Error("BASE_REF_NOT_FOUND: repo cache \u65E0\u53EF\u7528\u8FDC\u7AEF\u5F15\u7528\uFF08origin/HEAD / origin/main / origin/master\uFF09");
+}
+function refExists(repoPath, ref, env) {
+  try {
+    execFileSync9("git", ["-C", repoPath, "rev-parse", "--verify", ref], { env, stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function currentBranchName(repoPath) {
+  try {
+    const out = execFileSync9("git", ["-C", repoPath, "branch", "--show-current"], { encoding: "utf8", stdio: "pipe" }).trim();
+    return out || null;
+  } catch {
+    return null;
+  }
+}
+function hasLocalChanges2(repoPath, env) {
+  try {
+    const out = execFileSync9("git", ["-C", repoPath, "status", "--porcelain"], { encoding: "utf8", env, stdio: "pipe" }).trim();
+    return out.length > 0;
+  } catch {
+    return true;
   }
-  throw new Error("BASE_REF_NOT_FOUND: repo cache \u65E0\u53EF\u7528\u5F15\u7528\uFF08origin/main / origin/master / HEAD\uFF09");
 }
 function listMaterializedRepoDirs(taskRoot, options = {}) {
   const excluded = new Set(options.excludeDirs ?? []);
@@ -7031,10 +7139,14 @@ function syncGitIdentity(primaryDir, targetDir, env) {
 }
 function materializeAdditionalRepo(input) {
   if (existsSync14(join17(input.targetPath, ".git"))) {
-    execFileSync9("git", ["-C", input.targetPath, "fetch", "origin", "--prune"], { env: input.env, stdio: "pipe" });
+    const current = currentBranchName(input.targetPath);
+    if (!current && !hasLocalChanges2(input.targetPath, input.env)) {
+      const targetRef = resolveReadRef(input.repoCachePath, input.env, void 0, input.baseBranch);
+      execFileSync9("git", ["-C", input.targetPath, "checkout", "--detach", targetRef], { env: input.env, stdio: "pipe" });
+    }
     return input.targetPath;
   }
-  const candidates = input.baseBranch ? [`origin/${input.baseBranch}`, "origin/main", "origin/master", "HEAD"] : ["origin/main", "origin/master", "HEAD"];
+  const candidates = input.baseBranch ? [`origin/${input.baseBranch}`, "origin/main", "origin/master"] : ["origin/main", "origin/master"];
   let baseRef = null;
   for (const ref of candidates) {
     try {
@@ -7045,7 +7157,7 @@ function materializeAdditionalRepo(input) {
     }
   }
   if (!baseRef)
-    throw new Error("BASE_REF_NOT_FOUND: repo cache \u65E0\u53EF\u7528\u5F15\u7528\uFF08origin/<base> / origin/main / origin/master / HEAD\uFF09");
+    throw new Error("BASE_REF_NOT_FOUND: repo cache \u65E0\u53EF\u7528\u8FDC\u7AEF\u5F15\u7528\uFF08origin/<base> / origin/main / origin/master\uFF09");
   mkdirSync10(join17(input.targetPath, ".."), { recursive: true });
   execFileSync9("git", ["-C", input.repoCachePath, "worktree", "add", "--detach", input.targetPath, baseRef], {
     env: input.env,
@@ -8205,6 +8317,7 @@ var DaemonRunner = class {
       const wc = detail.workContext;
       repoBaseUrl = tokenRes.baseUrl;
       const remoteUrl = repoBaseUrl ? buildGitlabSshRemote(wc?.repoFullName ?? repo, repoBaseUrl) : void 0;
+      const daemonRemoteUrl = buildDaemonRepoUrl(wc?.repoFullName ?? repo, repoBaseUrl);
       env = { ...env, ...buildRepoEnv(tokenRes.token, repoBaseUrl) };
       if (wc?.baseBranch?.trim())
         env = { ...env, MORULA_BASE_BRANCH: wc.baseBranch.trim() };
@@ -8220,7 +8333,8 @@ var DaemonRunner = class {
           baseBranch: wc.baseBranch || "main",
           code: detail.code ?? null,
           env,
-          remoteUrl
+          remoteUrl,
+          daemonRemoteUrl
         });
         repoDir = managed.worktreePath;
         worktreePath = managed.worktreePath;
@@ -8229,7 +8343,7 @@ var DaemonRunner = class {
         });
         this.log(`[daemon] \u4EFB\u52A1 ${taskId} \u5DE5\u4F5C\u533A\u5C31\u7EEA: ${taskRoot}\uFF08\u4ED3\u5E93 ${repoDir}\uFF0Cbranch=${wc.branchName}\uFF09`);
       } else {
-        repoDir = ensureRepo(cfg.workdir, this.tenantId, repo, env, remoteUrl);
+        repoDir = ensureRepo(cfg.workdir, this.tenantId, repo, env, remoteUrl, daemonRemoteUrl);
         taskRoot = repoDir;
       }
       ensureGitIdentity(repoDir, detail.executor.executorName);

package/dist/morula.js

@@ -686,8 +686,8 @@ function page(ok, message) {
 }
 
 // ../morula-cli-core/dist/build-env.js
-var BUILD_VERSION = "0.1.0-alpha.6";
-var BUILD_ID = "20260917063948.nogit";
+var BUILD_VERSION = "0.1.0-alpha.7";
+var BUILD_ID = "20260917073516.nogit";
 var BUILD_CONTEXTS = {
   "local": "http://localhost:8080/api",
   "test": "https://morula.basecastle.com/api",

package/dist/plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "morula-cli",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.7",
   "description": "Use Morula CLI task management from DimCode.",
   "interface": {
     "displayName": "Morula CLI",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@arcships/morula-runtime",
   "type": "module",
-  "version": "0.1.0-alpha.6",
+  "version": "0.1.0-alpha.7",
   "description": "Device-level CLI for the Morula local agent runtime (daemon/portal/models/auth) and the Morula business CLI (morula), distributed via npm",
   "bin": {
     "morula-runtime": "./bin/morula-runtime.js",