@clawos-dev/clawd 0.2.659 → 0.2.661

package/dist/cli.cjs

@@ -63130,7 +63130,8 @@ async function latestRun(api, slug) {
 async function runByHead(api, slug, head) {
   return fetchRun(api, slug, `head_sha=${encodeURIComponent(head)}&per_page=1`);
 }
-async function findReleaseRun(api, slug, target) {
+var COMPLETED_JOBS_CACHE_MAX = 256;
+async function findReleaseRun(api, slug, target, jobsCache) {
   try {
     const branch = target.environment === "integration" ? "integration" : "main";
     if (target.environment === "production" && !target.promotionId) return void 0;
@@ -63142,38 +63143,47 @@ async function findReleaseRun(api, slug, target) {
       ));
       if (!Array.isArray(listed?.workflow_runs)) return void 0;
       const raw = listed.workflow_runs.find((r2) => r2.head_branch === branch && (target.environment === "production" ? r2.event === "workflow_dispatch" && r2.display_title === `persona-production-${target.promotionId}` : r2.head_sha === target.head && (r2.event === "push" || r2.event === "workflow_dispatch")));
-      if (raw) return readPinnedRun(api, slug, raw, target.environment, target.promotionId);
+      if (raw) return readPinnedRun(api, slug, raw, target.environment, target.promotionId, jobsCache);
       if (listed.workflow_runs.length < 100 && (listed.total_count === void 0 || page * 100 >= listed.total_count)) return null;
     }
   } catch {
   }
   return void 0;
 }
-async function runById(api, slug, runId, environment, promotionId) {
+async function runById(api, slug, runId, environment, promotionId, jobsCache) {
   try {
     const raw = await api.getJsonStrict(`/repos/${slug}/actions/runs/${runId}`);
     if (raw.id !== runId || raw.head_branch !== (environment === "integration" ? "integration" : "main")) return void 0;
     if (environment === "production" && (!promotionId || raw.display_title !== `persona-production-${promotionId}`)) return void 0;
-    return readPinnedRun(api, slug, raw, environment, promotionId);
+    return readPinnedRun(api, slug, raw, environment, promotionId, jobsCache);
   } catch {
     return void 0;
   }
 }
-async function readPinnedRun(api, slug, raw, environment, promotionId) {
+async function readPinnedRun(api, slug, raw, environment, promotionId, jobsCache) {
   if (typeof raw.id !== "number" || typeof raw.head_sha !== "string" || typeof raw.html_url !== "string") return void 0;
   const attempt = typeof raw.run_attempt === "number" ? raw.run_attempt : 1;
-  const byKey = /* @__PURE__ */ new Map();
-  for (let page = 1; page <= 30; page++) {
-    const listed = await api.getJsonStrict(`/repos/${slug}/actions/runs/${raw.id}/attempts/${attempt}/jobs?per_page=100&page=${page}`);
-    if (!Array.isArray(listed?.jobs)) return void 0;
-    for (const row of listed.jobs) {
-      const job = toJob(row);
-      if (job) byKey.set(job.key, job);
+  const status = runStatusOf(String(raw.status ?? ""));
+  const cacheKey = `${slug}:${raw.id}:${attempt}`;
+  let jobs = status === "completed" ? jobsCache?.get(cacheKey) : void 0;
+  if (!jobs) {
+    const byKey = /* @__PURE__ */ new Map();
+    for (let page = 1; page <= 30; page++) {
+      const listed = await api.getJsonStrict(`/repos/${slug}/actions/runs/${raw.id}/attempts/${attempt}/jobs?per_page=100&page=${page}`);
+      if (!Array.isArray(listed?.jobs)) return void 0;
+      for (const row of listed.jobs) {
+        const job = toJob(row);
+        if (job) byKey.set(job.key, job);
+      }
+      if (listed.jobs.length < 100 && (listed.total_count === void 0 || page * 100 >= listed.total_count)) break;
+      if (page === 30) return void 0;
+    }
+    jobs = DEPLOY_STAGE_KEYS.map((key) => byKey.get(key)).filter((j2) => j2 !== void 0);
+    if (status === "completed" && jobsCache) {
+      if (jobsCache.size >= COMPLETED_JOBS_CACHE_MAX) jobsCache.delete(jobsCache.keys().next().value);
+      jobsCache.set(cacheKey, jobs);
     }
-    if (listed.jobs.length < 100 && (listed.total_count === void 0 || page * 100 >= listed.total_count)) break;
-    if (page === 30) return void 0;
   }
-  const status = runStatusOf(String(raw.status ?? ""));
   return {
     runId: raw.id,
     headSha: raw.head_sha,
@@ -63185,7 +63195,7 @@ async function readPinnedRun(api, slug, raw, environment, promotionId) {
     ...typeof raw.event === "string" ? { event: raw.event } : {},
     ...status === "completed" ? { conclusion: raw.conclusion === "success" ? "success" : "failure" } : {},
     ...promotionId ? { promotionId } : {},
-    jobs: DEPLOY_STAGE_KEYS.map((key) => byKey.get(key)).filter((j2) => j2 !== void 0)
+    jobs
   };
 }
 async function fetchRun(api, slug, query) {
@@ -63258,6 +63268,7 @@ function reconcileInterruptedScans(deps) {
 var SECRETS_CACHE_MS = 2e4;
 var RUN_CACHE_MS = 4e3;
 var ONLINE_CACHE_MS = 2e4;
+var ONLINE_STALE_MS = 12e4;
 var directRead = async (_stage, action) => action();
 var UNPUBLISH_NEEDS_REPUBLISH = "\u8FD9\u4E2A persona \u7684\u6D41\u6C34\u7EBF\u662F\u65E7\u7248\u7684\uFF0C\u5148\u91CD\u65B0\u626B\u63CF\u3001\u53D1\u5E03\u4E00\u6B21\u518D\u4E0B\u7EBF";
 function ensureOwner(ctx) {
@@ -63349,20 +63360,42 @@ function buildDeployHandlers(deps) {
     return run;
   };
   const cloudCache = /* @__PURE__ */ new Map();
+  const cloudRefreshing = /* @__PURE__ */ new Set();
+  const cloudGeneration = /* @__PURE__ */ new Map();
+  const invalidateCloud = (key) => {
+    cloudCache.delete(key);
+    cloudGeneration.set(key, (cloudGeneration.get(key) ?? 0) + 1);
+  };
   const cachedCloud = async (personaId2, environment, run, unpublish, cloudName = personaId2, observe = () => deps.cloudState(cloudName, environment), fresh = false) => {
     const key = personaId2 + ":" + environment;
     const stamp = `${run?.runId ?? "-"}:${run?.runAttempt ?? "-"}:${run?.status ?? "-"}|${unpublish?.runId ?? "-"}:${unpublish?.status ?? "-"}`;
     const hit = cloudCache.get(key);
-    if (!fresh && hit && hit.stamp === stamp && deps.now() - hit.at < ONLINE_CACHE_MS) return hit.state;
-    let state;
-    try {
-      state = await observe();
-    } catch {
-      state = {};
+    const refresh = async () => {
+      const generation = cloudGeneration.get(key) ?? 0;
+      let state;
+      try {
+        state = await observe();
+      } catch {
+        state = {};
+      }
+      if ((cloudGeneration.get(key) ?? 0) === generation) cloudCache.set(key, { stamp, at: deps.now(), state });
+      return state;
+    };
+    if (!fresh && hit && hit.stamp === stamp) {
+      const age = deps.now() - hit.at;
+      if (age < ONLINE_CACHE_MS) return hit.state;
+      if (age < ONLINE_STALE_MS) {
+        if (!cloudRefreshing.has(key)) {
+          cloudRefreshing.add(key);
+          void refresh().finally(() => cloudRefreshing.delete(key));
+        }
+        return hit.state;
+      }
     }
-    cloudCache.set(key, { stamp, at: deps.now(), state });
-    return state;
+    return refresh();
   };
+  const completedJobs = /* @__PURE__ */ new Map();
+  const productionRunIds = /* @__PURE__ */ new Map();
   deps.githubIdentity.onChange(() => secretsCache.clear());
   async function requireGithub() {
     const auth = await deps.githubIdentity.refresh();
@@ -63449,28 +63482,36 @@ function buildDeployHandlers(deps) {
     }
     const { scans } = file;
     const selected = releaseId ? file.releases.find((r2) => r2.id === releaseId && (!environment || r2.environment === environment)) : releaseHead ? file.releases.find((r2) => r2.head === releaseHead && (!environment || r2.environment === environment)) : void 0;
+    const publisherFeishuAuthRead = scans.at(-1)?.manifest.connectors.some(isFeishuPublisherConnector) ? (async () => {
+      const query2 = async (environment2) => {
+        try {
+          return await measure("feishu.auth", () => deps.publisherFeishuAuth(repo2 ? cloudPersonaIdOf(repo2.url) : personaId2, environment2), { environment: environment2 });
+        } catch (e) {
+          return { connected: false, error: e instanceof Error ? e.message : "\u98DE\u4E66\u6388\u6743\u72B6\u6001\u67E5\u8BE2\u5931\u8D25" };
+        }
+      };
+      const [integration, production] = await Promise.all([query2("integration"), query2("production")]);
+      return { integration, production };
+    })() : void 0;
     let secrets;
     let run;
     let unpublish;
-    if (repo2 && api && github.status === "authorized") {
-      const legacy = historical ? selected : latestProductionRelease(file.releases);
-      run = legacy?.legacy ? await measure("run", () => cachedRun(personaId2, api, repoSlug(repo2.url), legacy.head), { environment: legacy.environment }) : void 0;
-      if (!historical) unpublish = await measure("unpublish", () => cachedUnpublish(personaId2, api, repoSlug(repo2.url)), { environment: "production" });
-    }
     let online;
     const targets = {};
     if (repo2 && api && github.status === "authorized") {
       const slug = repoSlug(repo2.url), cloudName = cloudPersonaIdOf(repo2.url);
+      const legacy = historical ? selected : latestProductionRelease(file.releases);
+      const legacyRunRead = legacy?.legacy ? measure("run", () => cachedRun(personaId2, api, slug, legacy.head), { environment: legacy.environment }) : Promise.resolve(void 0);
       const integration = historical ? selected?.environment === "integration" ? selected : void 0 : [...file.releases].reverse().find((r2) => r2.environment === "integration");
-      let intRun;
-      if (integration) {
-        intRun = await measure("run", async () => integration.runId ? runById(api, slug, integration.runId, "integration") : await findReleaseRun(api, slug, { environment: "integration", head: integration.head }) ?? void 0, { environment: "integration" });
-        if (intRun && intRun.headSha === integration.head) {
-          let updated = { ...integration, runId: intRun.runId, runAttempt: intRun.runAttempt };
-          if (integration.runAttempt !== intRun.runAttempt) updated = { ...updated, verified: void 0, artifactId: void 0, confirmation: void 0 };
-          if (intRun.status === "completed" && intRun.conclusion === "success" && !updated.verified) {
+      const intRunRead = (async () => {
+        if (!integration) return void 0;
+        const intRun2 = await measure("run", async () => integration.runId ? runById(api, slug, integration.runId, "integration", void 0, completedJobs) : await findReleaseRun(api, slug, { environment: "integration", head: integration.head }, completedJobs) ?? void 0, { environment: "integration" });
+        if (intRun2 && intRun2.headSha === integration.head) {
+          let updated = { ...integration, runId: intRun2.runId, runAttempt: intRun2.runAttempt };
+          if (integration.runAttempt !== intRun2.runAttempt) updated = { ...updated, verified: void 0, artifactId: void 0, confirmation: void 0 };
+          if (intRun2.status === "completed" && intRun2.conclusion === "success" && !updated.verified) {
             try {
-              const verifiedRun = intRun;
+              const verifiedRun = intRun2;
               const result = await measure("artifact", () => readVerifiedRelease(api, slug, verifiedRun));
               updated = { ...updated, artifactId: result.artifactId, verified: result.release };
             } catch {
@@ -63481,35 +63522,58 @@ function buildDeployHandlers(deps) {
             await writeScanFile(dir, file);
           }
         }
-      }
-      const promotion = file.promotions.at(-1);
-      const source = promotion && file.releases.find((r2) => r2.id === promotion.releaseId);
-      if (!historical && promotion?.verified && source && ["dispatched", "dispatching"].includes(promotion.phase)) {
-        await measure("promotion", () => continuePromotion(personaId2, { ...source, verified: promotion.verified }, promotion, false, api, async () => (await observe("production")).image));
-        file = await readHistory(dir);
-      }
-      const latestPromotion = file.promotions.at(-1);
-      let prodRun;
-      if (historical && selected?.environment === "production" && !selected.legacy && selected.runId) {
-        prodRun = await measure("run", () => runById(api, slug, selected.runId, "production", file.promotions.find((p3) => p3.id + "-production" === selected.id)?.id), { environment: "production" });
-        if (prodRun?.headSha !== selected.head) prodRun = void 0;
-      } else if (!historical && latestPromotion) {
-        const release2 = file.releases.find((r2) => r2.id === latestPromotion.releaseId);
-        if (release2) prodRun = await measure("run", async () => await findReleaseRun(api, slug, { environment: "production", head: release2.head, promotionId: latestPromotion.id }) ?? void 0, { environment: "production" });
-      }
-      const loadTarget = async (environment2, targetRun) => {
-        if (historical) return targetRun ? { run: targetRun } : {};
-        let targetSecretsList;
-        try {
-          targetSecretsList = await measure("secrets", () => targetSecrets(personaId2, dir, api, environment2), { environment: environment2 });
-        } catch {
+        return intRun2;
+      })();
+      const prodRunRead = (async () => {
+        const pending2 = file.promotions.at(-1);
+        if (!historical && pending2?.verified && ["dispatched", "dispatching"].includes(pending2.phase)) {
+          await intRunRead;
+          const source = file.releases.find((r2) => r2.id === pending2.releaseId);
+          if (source) {
+            await measure("promotion", () => continuePromotion(personaId2, { ...source, verified: pending2.verified }, pending2, false, api, async () => (await observe("production")).image));
+            file = await readHistory(dir);
+          }
+        }
+        const latestPromotion = file.promotions.at(-1);
+        if (historical && selected?.environment === "production" && !selected.legacy && selected.runId) {
+          const prodRun2 = await measure("run", () => runById(api, slug, selected.runId, "production", file.promotions.find((p3) => p3.id + "-production" === selected.id)?.id, completedJobs), { environment: "production" });
+          return prodRun2?.headSha !== selected.head ? void 0 : prodRun2;
+        }
+        if (!historical && latestPromotion) {
+          const release2 = file.releases.find((r2) => r2.id === latestPromotion.releaseId);
+          if (release2) return measure("run", async () => {
+            const key = personaId2 + ":" + latestPromotion.id;
+            const knownId = productionRunIds.get(key);
+            const found = (knownId ? await runById(api, slug, knownId, "production", latestPromotion.id, completedJobs) : void 0) ?? await findReleaseRun(api, slug, { environment: "production", head: release2.head, promotionId: latestPromotion.id }, completedJobs) ?? void 0;
+            if (found) productionRunIds.set(key, found.runId);
+            return found;
+          }, { environment: "production" });
         }
-        const targetUnpublish = await measure("unpublish", () => cachedUnpublish(personaId2, api, slug, environment2), { environment: environment2 });
+        return void 0;
+      })();
+      const loadTarget = async (environment2, runRead) => {
+        if (historical) {
+          const targetRun2 = await runRead;
+          return targetRun2 ? { run: targetRun2 } : {};
+        }
+        const [targetRun, targetSecretsList, targetUnpublish] = await Promise.all([
+          runRead,
+          measure("secrets", () => targetSecrets(personaId2, dir, api, environment2), { environment: environment2 }).catch(
+            () => void 0
+            /* unknown stays unknown */
+          ),
+          measure("unpublish", () => cachedUnpublish(personaId2, api, slug, environment2), { environment: environment2 })
+        ]);
+        const latestPromotion = file.promotions.at(-1);
         const cloud = file.releases.some((r2) => r2.environment === environment2) || environment2 === "production" && latestPromotion ? await measure("cloud", () => cachedCloud(personaId2, environment2, targetRun, targetUnpublish, cloudName, () => observe(environment2), snapshots.has(environment2)), { environment: environment2 }) : {};
         const { image, online: targetOnline } = cloud;
         return { ...targetUnpublish ? { unpublish: targetUnpublish } : {}, ...targetRun ? { run: targetRun } : {}, ...targetSecretsList ? { secrets: targetSecretsList } : {}, ...image ? { image } : {}, ...targetOnline !== void 0 ? { online: targetOnline } : {} };
       };
-      const [intTarget, prodTarget] = await Promise.all([loadTarget("integration", intRun), loadTarget("production", prodRun ?? (latestProductionRelease(file.releases)?.legacy ? run : void 0))]);
+      const productionRunRead = Promise.all([prodRunRead, legacyRunRead]).then(([prodRun2, legacyRun2]) => prodRun2 ?? (latestProductionRelease(file.releases)?.legacy ? legacyRun2 : void 0));
+      const settled = await Promise.allSettled([loadTarget("integration", intRunRead), loadTarget("production", productionRunRead), intRunRead, prodRunRead, legacyRunRead]);
+      const failure = settled.find((r2) => r2.status === "rejected");
+      if (failure) throw failure.reason;
+      const [intTarget, prodTarget, intRun, prodRun, legacyRun] = settled.map((r2) => r2.value);
       targets.integration = intTarget;
       targets.production = prodTarget;
       if (!historical) {
@@ -63517,21 +63581,10 @@ function buildDeployHandlers(deps) {
         unpublish = prodTarget.unpublish;
         secrets = prodTarget.secrets;
       }
-      run = historical ? selected?.environment === "integration" ? intRun : prodRun ?? run : prodTarget.run;
+      run = historical ? selected?.environment === "integration" ? intRun : prodRun ?? legacyRun : prodTarget.run;
     }
     if (!historical && latestProductionRelease(file.releases) && (!api || github.status !== "authorized")) online = (await measure("cloud", () => cachedCloud(personaId2, "production", run, unpublish, repo2 ? cloudPersonaIdOf(repo2.url) : personaId2), { environment: "production" })).online;
-    let publisherFeishuAuth;
-    if (scans.at(-1)?.manifest.connectors.some(isFeishuPublisherConnector)) {
-      const query2 = async (environment2) => {
-        try {
-          return await measure("feishu.auth", () => deps.publisherFeishuAuth(repo2 ? cloudPersonaIdOf(repo2.url) : personaId2, environment2), { environment: environment2 });
-        } catch (e) {
-          return { connected: false, error: e instanceof Error ? e.message : "\u98DE\u4E66\u6388\u6743\u72B6\u6001\u67E5\u8BE2\u5931\u8D25" };
-        }
-      };
-      const [integration, production] = await Promise.all([query2("integration"), query2("production")]);
-      publisherFeishuAuth = { integration, production };
-    }
+    const publisherFeishuAuth = await publisherFeishuAuthRead;
     return {
       personaId: personaId2,
       github,
@@ -63680,7 +63733,12 @@ function buildDeployHandlers(deps) {
       if (/[\s\p{Cc}]/u.test(apiKey)) throw invalid("key \u91CC\u4E0D\u80FD\u6709\u7A7A\u767D\u6216\u63A7\u5236\u5B57\u7B26\uFF08\u591A\u534A\u662F\u7C98\u8D34\u65F6\u5E26\u8FDB\u4E86\u6362\u884C\u6216\u7A7A\u683C\uFF09");
       writes = [[ENGINE_AUTH_SECRETS.apiKey, apiKey], [ENGINE_AUTH_SECRETS.baseUrl, baseUrl]];
     }
-    const { api } = await requireGithub();
+    const { auth: githubAuth, api } = await requireGithub();
+    try {
+      await ensureRepo(deps.exec, api, { dir, org: deps.org, personaId: args.personaId, auth: githubAuth });
+    } catch (err) {
+      throw toClawdError(err);
+    }
     const before = await readHistory(dir);
     await writeScanFile(dir, { ...before, engineChannels: { ...before.engineChannels, [args.environment]: null } });
     try {
@@ -63965,7 +64023,7 @@ function buildDeployHandlers(deps) {
       throw new ClawdError(ERROR_CODES.INTERNAL, err instanceof Error ? err.message : String(err));
     }
     unpublishCache.delete(personaId2 + ":" + environment);
-    cloudCache.delete(personaId2 + ":" + environment);
+    invalidateCloud(personaId2 + ":" + environment);
     return { response: { type: "deploy:unpublish", before: before?.runId ?? null } };
   };
   function releaseArgs(frame, schema) {
@@ -74650,7 +74708,7 @@ function computeMethodAccess(args) {
 }
 
 // src/version.ts
-var version = "0.2.659".length > 0 ? "0.2.659" : "dev";
+var version = "0.2.661".length > 0 ? "0.2.661" : "dev";
 
 // src/cli-probe/probe.ts
 var fs85 = __toESM(require("fs"), 1);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawos-dev/clawd",
-  "version": "0.2.659",
+  "version": "0.2.661",
   "description": "Standalone clawd daemon — Claude Code (and future Codex) session server over WebSocket",
   "type": "module",
   "license": "MIT",