@proagentstore/cli 0.4.91 → 0.4.93

package/dist/browser-runner/local-artifact/contract.js

@@ -20,6 +20,8 @@ export const LOCAL_ARTIFACT_TASK_TYPE = "local_artifact.generate";
 export const LOCAL_ARTIFACT_RUN_PATH = "/local-artifact/run";
 export const LOCAL_ARTIFACT_STATUS_PATH = "/local-artifact/status";
 export const LOCAL_ARTIFACT_CANCEL_PATH = "/local-artifact/cancel";
+/** First CLI that consumes an explicit uploaded source instead of its local master files. */
+export const LOCAL_ARTIFACT_UPLOADED_SOURCES_MIN_CLI = "0.4.93";
 /** The readiness event a completed tailoring run emits, once, through the connection outbox. */
 export const MATERIALS_READY_EVENT = "job.application.materials_ready";
 export const LOCAL_ARTIFACT_ENGINES = ["claude", "codex"];

package/dist/browser-runner/local-artifact/runtime.js

@@ -67,6 +67,26 @@ export function parseArtifactEnvelope(raw) {
             throw bad(`source ${String(r.role)} is listed twice`);
         sources.push({ role: r.role, path: r.path });
     }
+    const uploadedSources = [];
+    if (o.uploadedSources !== undefined) {
+        if (!Array.isArray(o.uploadedSources) || o.uploadedSources.length !== 2)
+            throw bad("uploadedSources must contain the selected resume and profile");
+        for (const source of o.uploadedSources) {
+            const r = (source && typeof source === "object" ? source : {});
+            if ((r.role !== "resume" && r.role !== "profile") || uploadedSources.some((x) => x.role === r.role))
+                throw bad("uploaded sources need one resume and one profile");
+            if (typeof r.fileId !== "string" || !PATH_SEGMENT.test(r.fileId) || typeof r.version !== "string" || !r.version || r.version.length > 300 || typeof r.originalSha256 !== "string" || !/^[a-f0-9]{64}$/.test(r.originalSha256) || typeof r.extractedTextSha256 !== "string" || !/^[a-f0-9]{64}$/.test(r.extractedTextSha256) || typeof r.extractedAt !== "string" || Number.isNaN(Date.parse(r.extractedAt)) || typeof r.text !== "string")
+                throw bad("uploaded source provenance is invalid");
+            const bytes = Buffer.byteLength(r.text, "utf8");
+            if (!bytes || bytes > LOCAL_ARTIFACT_CAPS.sourceBytes)
+                throw bad(`uploaded source must be 1-${LOCAL_ARTIFACT_CAPS.sourceBytes} UTF-8 bytes`);
+            if (sha256(r.text) !== r.extractedTextSha256)
+                throw bad("uploaded source text does not match its extracted-text hash");
+            uploadedSources.push({ role: r.role, fileId: r.fileId, version: r.version, originalSha256: r.originalSha256, extractedTextSha256: r.extractedTextSha256, extractedAt: r.extractedAt, text: r.text });
+        }
+        if (uploadedSources.length !== 2 || !uploadedSources.some((s) => s.role === "resume") || !uploadedSources.some((s) => s.role === "profile"))
+            throw bad("uploaded sources need one resume and one profile");
+    }
     const p = (o.policy && typeof o.policy === "object" ? o.policy : {});
     const retainDays = intIn(p.retainDays, 0, 3650);
     const maxMinutes = intIn(p.maxMinutes, 1, 60);
@@ -83,6 +103,7 @@ export function parseArtifactEnvelope(raw) {
         authMode: o.authMode,
         workspace: o.workspace,
         sources,
+        ...(uploadedSources.length ? { uploadedSources } : {}),
         policy: { retainDays, maxMinutes, maxConcurrent },
         ...("lead" in lead ? { lead: lead.lead } : { lead: null, leadError: lead.error }),
     };
@@ -163,31 +184,53 @@ export class LocalArtifactRuntime {
             throw new Pause("workspace_unavailable", [`The workspace ${e.workspace} cannot be used: ${err instanceof Error ? err.message : String(err)}`]);
         }
         this.sweepArtifacts(run, workspace);
-        // Sources: read by the runtime, hashed, handed to the CLI in its prompt. Content never leaves this function except into the prompt.
+        // Sources: uploaded selections arrive only over the authenticated relay, are written beneath
+        // this run's private scratch folder under fixed role names, and never use a user filename/path.
+        // Local mode remains the existing path. Content never reaches events/results/DB.
         const texts = [];
         const hashes = [];
         const missing = [];
-        for (const s of e.sources) {
-            const shown = `${e.workspace}/${s.path}`;
-            try {
-                const file = resolveSource(workspace, s.path);
-                const buf = readFileSync(file);
-                if (buf.length > LOCAL_ARTIFACT_CAPS.sourceBytes)
-                    throw new Error(`larger than ${LOCAL_ARTIFACT_CAPS.sourceBytes / 1024} KB`);
-                if (!buf.length)
-                    throw new Error("empty");
-                texts.push({ role: s.role, text: buf.toString("utf8") });
-                const hash = { role: s.role, path: shown, sha256: sha256(buf), bytes: buf.length };
-                hashes.push(hash);
-                this.emit(run, { type: "source.read", detail: hash });
-            }
-            catch (err) {
-                this.emit(run, { type: "source.missing", detail: { role: s.role, path: shown } });
-                missing.push(`Your ${s.role} at ${shown} could not be read (${err instanceof Error && !/ENOENT/.test(err.message) ? err.message : "not found"}). Add it, or choose another file in the Application Tailor settings.`);
+        if (e.uploadedSources?.length) {
+            const sourceDir = join(run.scratch, "sources");
+            mkdirSync(sourceDir, { recursive: true, mode: 0o700 });
+            for (const s of e.uploadedSources) {
+                const safePath = join(sourceDir, `${s.role}.txt`);
+                try {
+                    writeFileSync(safePath, s.text, { encoding: "utf8", flag: "wx", mode: 0o600 });
+                    const bytes = Buffer.byteLength(s.text, "utf8");
+                    const hash = { role: s.role, path: `uploaded/${s.fileId}@${s.version}`, sha256: s.extractedTextSha256, bytes };
+                    texts.push({ role: s.role, text: readFileSync(safePath, "utf8") });
+                    hashes.push(hash);
+                    this.emit(run, { type: "source.read", detail: hash });
+                }
+                catch (err) {
+                    this.emit(run, { type: "source.missing", detail: { role: s.role, path: `uploaded/${s.fileId}` } });
+                    missing.push(`The selected uploaded ${s.role} could not be materialized (${err instanceof Error ? err.message : "unknown error"}).`);
+                }
             }
         }
+        else
+            for (const s of e.sources) {
+                const shown = `${e.workspace}/${s.path}`;
+                try {
+                    const file = resolveSource(workspace, s.path);
+                    const buf = readFileSync(file);
+                    if (buf.length > LOCAL_ARTIFACT_CAPS.sourceBytes)
+                        throw new Error(`larger than ${LOCAL_ARTIFACT_CAPS.sourceBytes / 1024} KB`);
+                    if (!buf.length)
+                        throw new Error("empty");
+                    texts.push({ role: s.role, text: buf.toString("utf8") });
+                    const hash = { role: s.role, path: shown, sha256: sha256(buf), bytes: buf.length };
+                    hashes.push(hash);
+                    this.emit(run, { type: "source.read", detail: hash });
+                }
+                catch (err) {
+                    this.emit(run, { type: "source.missing", detail: { role: s.role, path: shown } });
+                    missing.push(`Your ${s.role} at ${shown} could not be read (${err instanceof Error && !/ENOENT/.test(err.message) ? err.message : "not found"}). Add it, or choose another file in the Application Tailor settings.`);
+                }
+            }
         for (const role of REQUIRED_SOURCE_ROLES) {
-            if (!e.sources.some((s) => s.role === role))
+            if (e.uploadedSources?.length ? !e.uploadedSources.some((s) => s.role === role) : !e.sources.some((s) => s.role === role))
                 missing.push(`No ${role} source is configured. Choose one in the Application Tailor settings.`);
         }
         if (missing.length)

package/dist/index.js

@@ -1716,6 +1716,152 @@ function mayAutomaticallyRestart(input) {
   return input.authoritative && input.enabled && input.workObserved && input.busy.length === 0;
 }
 
+// src/commands/runner/auto-update-controller.ts
+var AutomaticUpdateController = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    this.clearTimer = deps.clearTimer ?? ((timer) => clearTimeout(timer));
+  }
+  deps;
+  timer = null;
+  checking = false;
+  waiting = false;
+  installing = false;
+  failures = 0;
+  setTimer;
+  clearTimer;
+  /** Called only for a true policy transition. `keep` deliberately leaves a due heartbeat timer alone. */
+  onPolicy(action) {
+    if (action === "cancel") return this.cancel();
+    if (action === "start") this.schedule(true);
+  }
+  /** Testable immediate entry point; production reaches it through the scheduled timer. */
+  async runNow() {
+    const current = this.deps.policy();
+    if (this.checking || this.waiting || !current.authoritative || !current.value.autoUpdate) return;
+    this.checking = true;
+    try {
+      if (!await this.deps.refreshPolicy() || !this.enabled()) {
+        this.deps.status("offline", { reason: "The owner policy could not be refreshed; automatic update is deferred." });
+        return;
+      }
+      await this.decide(false);
+    } catch (error) {
+      this.fail(error);
+    } finally {
+      this.checking = false;
+    }
+  }
+  /** Explicit remote updates and unattended checks share this single flight. */
+  async installManually(plan) {
+    return this.install(plan, false);
+  }
+  enabled() {
+    const { value, authoritative } = this.deps.policy();
+    return authoritative && value.autoUpdate;
+  }
+  schedule(initial = false) {
+    if (!this.enabled() || this.timer || this.waiting) return;
+    const delay = initial ? Math.round(5e3 + (this.deps.random ?? Math.random)() * 25e3) : nextAutoUpdateDelayMs(this.failures, this.deps.random);
+    this.timer = this.setTimer(() => {
+      this.timer = null;
+      void this.runNow();
+    }, delay);
+    this.timer.unref?.();
+  }
+  cancel() {
+    if (this.timer) this.clearTimer(this.timer);
+    this.timer = null;
+  }
+  fail(error) {
+    this.failures++;
+    this.deps.status("failure", { reason: error instanceof Error ? error.message : String(error) });
+    this.schedule();
+  }
+  async decide(deferred) {
+    const facts = await this.deps.facts();
+    if (!this.enabled()) return;
+    const plan = this.deps.plan(facts);
+    if (plan.action === "up-to-date") {
+      this.failures = 0;
+      this.deps.status("verified-success", { latestVersion: facts.latest ?? void 0, reason: void 0 });
+      this.schedule();
+      return;
+    }
+    if (plan.action === "refused") {
+      this.deps.status("unsupported", { reason: plan.reason });
+      this.schedule();
+      return;
+    }
+    if (plan.action === "wait") {
+      this.deps.status("waiting-for-idle", { latestVersion: plan.latest, reason: void 0 });
+      this.defer();
+      return;
+    }
+    this.deps.status("running", { latestVersion: plan.latest, reason: void 0 });
+    const restarted = await this.install(plan, true);
+    if (restarted) this.deps.status("restarting", { latestVersion: plan.latest, reason: void 0 });
+    else if (!deferred) this.defer(plan.latest);
+  }
+  defer(latest) {
+    if (this.waiting) return;
+    this.waiting = true;
+    this.timer = this.setTimer(() => {
+      this.timer = null;
+      void (async () => {
+        this.waiting = false;
+        try {
+          if (!await this.deps.refreshPolicy() || !this.enabled()) {
+            this.deps.status("offline", { reason: "The owner policy could not be refreshed; automatic update is deferred." });
+            return;
+          }
+          await this.decide(true);
+        } catch (error) {
+          this.fail(error);
+        }
+      })();
+    }, 15e3);
+    this.timer.unref?.();
+    this.deps.status("waiting-for-idle", latest ? { latestVersion: latest } : void 0);
+  }
+  async install(plan, automatic) {
+    if (this.installing) return false;
+    this.installing = true;
+    try {
+      return await this.deps.installAndRestart(plan, automatic);
+    } finally {
+      this.installing = false;
+    }
+  }
+};
+var RelayMutationAdmission = class {
+  draining = false;
+  inFlight = 0;
+  waiters = [];
+  begin() {
+    if (this.draining) return null;
+    this.inFlight++;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.inFlight--;
+      if (this.inFlight === 0) {
+        for (const wake of this.waiters.splice(0)) wake();
+      }
+    };
+  }
+  async drain() {
+    this.draining = true;
+    if (this.inFlight === 0) return;
+    await new Promise((resolve5) => this.waiters.push(resolve5));
+  }
+  resume() {
+    this.draining = false;
+  }
+};
+
 // src/commands/runner/relay.ts
 var MEMBERSHIP_SYNC_PATH = "/pags/membership/sync";
 var CLI_CONTROL_PATHS = /* @__PURE__ */ new Set([MEMBERSHIP_SYNC_PATH, RUNNER_UPDATE_PATH]);
@@ -1839,7 +1985,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   };
   let updateInstallInFlight = false;
   let installedPendingRestart = null;
-  let automaticRestartDraining = false;
+  const relayMutationAdmission = new RelayMutationAdmission();
   const installAndRestart = async (plan, automatic = false) => {
     if (updateInstallInFlight) return false;
     updateInstallInFlight = true;
@@ -1858,17 +2004,17 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
       }
     }
     if (automatic) {
-      automaticRestartDraining = true;
+      await relayMutationAdmission.drain();
       await new Promise((resolve5) => setTimeout(resolve5, 500));
       if (!await refreshAutomaticPolicy() || !autoUpdatePolicy.autoUpdate) {
-        automaticRestartDraining = false;
+        relayMutationAdmission.resume();
         updateInstallInFlight = false;
         return false;
       }
     }
     const finalFacts = await updateFacts();
     if (finalFacts.busy.length || automatic && !mayAutomaticallyRestart({ authoritative: autoUpdatePolicyAuthoritative, enabled: autoUpdatePolicy.autoUpdate, workObserved: !finalFacts.busy.includes("runner-work-observation-unavailable"), busy: finalFacts.busy })) {
-      automaticRestartDraining = false;
+      relayMutationAdmission.resume();
       updateInstallInFlight = false;
       return false;
     }
@@ -1985,6 +2131,17 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     }, delay);
     automaticTimer.unref();
   };
+  const automaticUpdateController = new AutomaticUpdateController({
+    policy: () => ({ value: autoUpdatePolicy, authoritative: autoUpdatePolicyAuthoritative }),
+    refreshPolicy: refreshAutomaticPolicy,
+    facts: updateFacts,
+    plan: planRunnerUpdate,
+    // This bridge is deliberately the same function used by explicit runner_update. It owns npm,
+    // a fresh authoritative policy, the mutation drain, final local-work observation and restart.
+    installAndRestart,
+    status: saveAutoUpdateStatus
+  });
+  scheduleAutomaticUpdate = (initial = false, cancel = false) => automaticUpdateController.onPolicy(cancel ? "cancel" : initial ? "start" : "keep");
   if (autoUpdatePolicyAuthoritative && autoUpdatePolicy.autoUpdate) scheduleAutomaticUpdate(true);
   const answerUpdate = async (body) => {
     const dryRun = body?.dryRun === true;
@@ -1995,7 +2152,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
       return { status: 200, result: { ...plan, detail: "Restarts itself as soon as these engines finish their turns \u2014 no run is cut off." } };
     }
     try {
-      if (!await installAndRestart(plan)) return { status: 409, result: { error: "A runner update is already installing or restarting." } };
+      if (!await automaticUpdateController.installManually(plan)) return { status: 409, result: { error: "A runner update is already installing or restarting." } };
     } catch (e) {
       return { status: 500, result: { error: `npm could not install ${plan.latest}: ${e instanceof Error ? e.message : String(e)}` } };
     }
@@ -2064,7 +2221,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
         runnerNode,
         // The final automatic-update drain is an admission gate, not merely another poll:
         // command work starts only when the old runner is still permitted to serve it.
-        () => !automaticRestartDraining
+        () => relayMutationAdmission.begin()
       )
     );
     if (label) writeLine(`Attached agent: ${label}`);
@@ -2208,7 +2365,7 @@ async function readSessionResources(localUrl, runnerToken) {
 }
 var RTT_PROBE_PREFIX = "rtt:";
 var RTT_ECHO_PREFIX = "rtt-echo:";
-function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, force = false, onConflict, onOpen, onControl, runnerNode = hostname3(), admitMutation = () => true) {
+function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, force = false, onConflict, onOpen, onControl, runnerNode = hostname3(), beginMutation = () => () => void 0) {
   let backoffMs = 1e3;
   let reconnecting = false;
   let closed = false;
@@ -2276,7 +2433,8 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
         return;
       }
       const method = (cmd.method || "POST").toUpperCase();
-      if (method !== "GET" && method !== "HEAD" && !admitMutation()) {
+      const releaseMutation = method !== "GET" && method !== "HEAD" ? beginMutation() : null;
+      if (method !== "GET" && method !== "HEAD" && !releaseMutation) {
         try {
           ws.send(JSON.stringify({ id: cmd.id, status: 503, result: { error: "Runner is draining for a safe automatic update; retry shortly." } }));
         } catch {
@@ -2310,6 +2468,8 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
           ws.send(JSON.stringify({ id: cmd.id, status: 500, error: err instanceof Error ? err.message : String(err) }));
         } catch {
         }
+      } finally {
+        releaseMutation?.();
       }
     };
     ws.onclose = (ev) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-	"version": "0.4.91",
+  "version": "0.4.93",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",