nolo-cli 0.148.0-alpha.1 → 0.151.0-alpha.2

package/workloadLifecycle-36DXRZKU.js

@@ -0,0 +1,320 @@
+import {
+  Database
+} from "./chunk-IT3ZZRJE.js";
+import {
+  buildPrimaryExecutionTicket,
+  createDockerToolChannel,
+  dockerExecutionToolNames
+} from "./chunk-6MJNEXUU.js";
+import {
+  DOCKER_SANDBOX_BACKEND_ID,
+  confirmDockerSandboxStopped,
+  createDockerSandboxExecutionBackend,
+  defaultRunSbx,
+  resolveMaxActiveSandboxesFromEnv
+} from "./chunk-YVPQATSC.js";
+import "./chunk-PWTNI4N7.js";
+import "./chunk-TNIX77YM.js";
+import "./chunk-4VNS5WPM.js";
+
+// packages/agent-runtime/docker/workloadLifecycle.ts
+import { randomUUID } from "node:crypto";
+import { isAbsolute } from "node:path";
+function shQuote(value) {
+  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+}
+function createTrustedDockerBindingAuthorizer(bindings) {
+  const map = /* @__PURE__ */ new Map();
+  for (const b of bindings) {
+    if (!b?.authorizedOwner || !b.dockerAccount || !b.credentialContextId) continue;
+    map.set(b.authorizedOwner, { authorizedOwner: b.authorizedOwner, dockerAccount: b.dockerAccount, credentialContextId: b.credentialContextId });
+  }
+  const authorizer = async ({ authenticatedCaller }) => {
+    const found = map.get(authenticatedCaller);
+    if (!found) return { allowed: false };
+    return { allowed: true, binding: { ...found } };
+  };
+  authorizer.isBound = (caller) => map.has(caller);
+  return authorizer;
+}
+function getTrustedDockerBindings(env) {
+  const raw = env.NOLO_DOCKER_BINDINGS;
+  if (!raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function createDockerBindingAuthorizer(env) {
+  return createTrustedDockerBindingAuthorizer(getTrustedDockerBindings(env));
+}
+var DEFAULT_MAX_ACTIVE_RUNS_PER_ACCOUNT = 3;
+var PRE_CREATE_FAILURE_CODES = /* @__PURE__ */ new Set([
+  "quota-unverifiable",
+  "quota-insufficient",
+  "concurrency-rejected",
+  "quota-record-failed",
+  "invalid-ticket",
+  "lease-not-found",
+  "lease-mismatch",
+  "lease-released",
+  "unsupported-request"
+]);
+function prepareMayHaveLeftSandbox(error) {
+  const err = error;
+  if (err?.cleanupPending === true) return true;
+  const code = typeof err?.code === "string" ? err.code : void 0;
+  if (code !== void 0 && PRE_CREATE_FAILURE_CODES.has(code)) return false;
+  return true;
+}
+function resolveMaxActiveRunsPerAccount(requestedMax, env = {}) {
+  if (typeof requestedMax === "number" && Number.isInteger(requestedMax) && requestedMax > 0) return requestedMax;
+  return resolveMaxActiveSandboxesFromEnv(env) ?? DEFAULT_MAX_ACTIVE_RUNS_PER_ACCOUNT;
+}
+var DockerWorkloadLifecycle = class {
+  constructor(options) {
+    this.options = options;
+    this.maxActiveRunsPerAccount = resolveMaxActiveRunsPerAccount(options.maxActiveRunsPerAccount, options.env ?? {});
+    if (options.topology !== "single-host-shared-sqlite" || !isAbsolute(options.journalPath)) {
+      throw new Error("docker_atomic_admission_not_configured");
+    }
+    this.db = new Database(options.journalPath, { create: true });
+    this.db.exec("PRAGMA journal_mode=WAL; PRAGMA synchronous=FULL; PRAGMA busy_timeout=5000;");
+    this.db.exec(`CREATE TABLE IF NOT EXISTS docker_runs (
+            runId TEXT PRIMARY KEY, authenticatedCaller TEXT NOT NULL,
+            authorizedOwner TEXT NOT NULL, dockerAccount TEXT NOT NULL,
+            credentialContextId TEXT NOT NULL, sandbox TEXT NOT NULL UNIQUE,
+            state TEXT NOT NULL, cleanupPending INTEGER NOT NULL, createdAt INTEGER NOT NULL
+        );
+        DROP INDEX IF EXISTS docker_account_reservation;
+        CREATE INDEX IF NOT EXISTS docker_runs_account_active ON docker_runs(dockerAccount, state);
+        CREATE TABLE IF NOT EXISTS docker_authorization_audit (
+            id TEXT PRIMARY KEY, runId TEXT NOT NULL, authenticatedCaller TEXT NOT NULL,
+            authorizedOwner TEXT, dockerAccount TEXT, credentialContextId TEXT,
+            authorizationResult TEXT NOT NULL, accountAttestation TEXT NOT NULL DEFAULT 'operator-declared',
+            observedAt INTEGER NOT NULL
+        );`);
+  }
+  db;
+  maxActiveRunsPerAccount;
+  /** BEGIN IMMEDIATE: cleanup_pending continues to occupy the account slot. */
+  admitRun(row) {
+    const admit = this.db.transaction((r) => {
+      const { active } = this.db.query("SELECT COUNT(*) AS active FROM docker_runs WHERE dockerAccount=? AND state!='released'").get(r.dockerAccount);
+      if (active >= this.maxActiveRunsPerAccount) throw new Error("docker_atomic_admission_rejected_account_limit");
+      this.db.query("INSERT INTO docker_runs VALUES (?, ?, ?, ?, ?, ?, 'cleanup_pending', 1, ?)").run(
+        r.runId,
+        r.authenticatedCaller,
+        r.authorizedOwner,
+        r.dockerAccount,
+        r.credentialContextId,
+        r.sandbox,
+        Date.now()
+      );
+    });
+    try {
+      admit.immediate(row);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "";
+      if (message === "docker_atomic_admission_rejected_account_limit") throw error;
+      throw new Error("docker_atomic_admission_rejected");
+    }
+  }
+  close() {
+    this.db.close();
+  }
+  audit(runId, caller, result, binding) {
+    this.db.query(`INSERT INTO docker_authorization_audit VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(
+      randomUUID(),
+      runId,
+      caller,
+      binding?.authorizedOwner ?? null,
+      binding?.dockerAccount ?? null,
+      binding?.credentialContextId ?? null,
+      result,
+      "operator-declared",
+      Date.now()
+    );
+  }
+  async stopAndConfirm(row) {
+    const deps = this.options.resolveAccount(row);
+    const runSbx = deps.runSbx ?? defaultRunSbx;
+    this.db.query("UPDATE docker_runs SET state='cleanup_pending', cleanupPending=1 WHERE runId=? AND state!='released'").run(row.runId);
+    try {
+      await runSbx(["--cloud", "stop", row.sandbox], { timeoutMs: 1e4 });
+    } catch {
+    }
+    const stopConfirm = { attempts: 10, delayMs: 2e3, ...this.options.stopConfirm };
+    if (!await confirmDockerSandboxStopped(runSbx, row.sandbox, 1e4, stopConfirm)) {
+      throw new Error("docker_stop_unverified_cleanup_pending");
+    }
+    this.db.query("UPDATE docker_runs SET state='released', cleanupPending=0 WHERE runId=?").run(row.runId);
+  }
+  async recover() {
+    const rows = this.db.query("SELECT * FROM docker_runs WHERE state!='released'").all();
+    const released = [], pending = [];
+    for (const row of rows) {
+      try {
+        if (!await this.options.isRunInactive?.(row.runId)) {
+          pending.push(row.runId);
+          continue;
+        }
+        await this.stopAndConfirm(row);
+        released.push(row.runId);
+      } catch {
+        pending.push(row.runId);
+      }
+    }
+    return { released, pending };
+  }
+  async run(input, body) {
+    const { runId, authenticatedCaller, grant, signal } = input;
+    if (!runId || !authenticatedCaller) throw new Error("docker_authenticated_identity_required");
+    let decision;
+    try {
+      decision = await this.options.authorize?.({ authenticatedCaller, runId }) ?? { allowed: false };
+    } catch {
+      this.audit(runId, authenticatedCaller, "denied");
+      throw new Error("docker_account_binding_denied");
+    }
+    const binding = decision.allowed ? decision.binding : void 0;
+    if (!binding?.authorizedOwner || !binding.dockerAccount || !binding.credentialContextId) {
+      this.audit(runId, authenticatedCaller, "denied");
+      throw new Error("docker_account_binding_denied");
+    }
+    if (binding.authorizedOwner !== authenticatedCaller) {
+      this.audit(runId, authenticatedCaller, "denied", binding);
+      throw new Error("docker_caller_mismatch");
+    }
+    this.audit(runId, authenticatedCaller, "allowed", binding);
+    if (signal?.aborted) throw new Error("docker_run_cancelled");
+    const ticket = buildPrimaryExecutionTicket(grant, "oneshot");
+    if (ticket.callerUserId && ticket.callerUserId !== authenticatedCaller) {
+      this.audit(runId, authenticatedCaller, "denied", binding);
+      throw new Error("docker_caller_mismatch");
+    }
+    const deps = this.options.resolveAccount(binding);
+    if (!deps.kvStore || !deps.quotaProvider) throw new Error("docker_account_backend_not_configured");
+    if (deps.dockerAccount && deps.dockerAccount !== binding.dockerAccount) throw new Error("docker_quota_account_mismatch");
+    if (deps.owner && deps.owner !== binding.authorizedOwner) throw new Error("docker_quota_owner_mismatch");
+    const row = { ...binding, runId, authenticatedCaller, sandbox: `nolo-run-${randomUUID()}`, state: "cleanup_pending" };
+    this.admitRun(row);
+    let active = true;
+    let inFlight = Promise.resolve();
+    let backend;
+    let lease;
+    let completed = false, bodyReached = false, mayHaveSandbox = false;
+    let prepareFailureCode;
+    try {
+      backend = createDockerSandboxExecutionBackend({
+        ...deps,
+        owner: binding.authorizedOwner,
+        dockerAccount: binding.dockerAccount,
+        sandboxName: row.sandbox,
+        ...typeof deps.quotaVerify === "boolean" ? { quotaVerify: deps.quotaVerify } : typeof this.options.quotaVerify === "boolean" ? { quotaVerify: this.options.quotaVerify } : {},
+        maxActiveSandboxesPerAccount: deps.maxActiveSandboxesPerAccount ?? resolveMaxActiveSandboxesFromEnv(this.options.env ?? {}) ?? this.maxActiveRunsPerAccount
+      });
+      try {
+        lease = await backend.prepare(ticket);
+        mayHaveSandbox = true;
+      } catch (prepareError) {
+        mayHaveSandbox = prepareMayHaveLeftSandbox(prepareError);
+        prepareFailureCode = typeof prepareError?.code === "string" ? prepareError.code : void 0;
+        throw prepareError;
+      }
+      this.db.query("UPDATE docker_runs SET state='active' WHERE runId=?").run(runId);
+      bodyReached = true;
+      const boundBackend = backend, boundLease = lease;
+      const workload = { kind: "docker", channel: createDockerToolChannel(grant, {
+        supportedToolNames: [...dockerExecutionToolNames],
+        execute: (request) => {
+          const job = inFlight.then(async () => {
+            if (!active || signal?.aborted || request.signal?.aborted) throw new Error("docker_run_not_active");
+            const argv = request.argv !== void 0 && request.argv.length > 0 ? [...request.argv] : request.command !== void 0 ? ["bash", "-lc", request.cwd !== void 0 ? `cd ${shQuote(request.cwd)} && ${request.command}` : request.command] : void 0;
+            if (!argv) throw new Error("docker_request_missing_command");
+            const result2 = await boundBackend.execute(boundLease, { kind: "command", argv });
+            return JSON.stringify(result2);
+          });
+          inFlight = job.catch(() => void 0);
+          return job;
+        }
+      }) };
+      const runtime = {
+        exec: (argv) => {
+          const job = inFlight.then(async () => {
+            if (!active || signal?.aborted) throw new Error("docker_run_not_active");
+            const result2 = await boundBackend.execute(boundLease, { kind: "command", argv: [...argv] });
+            const output = result2?.output;
+            const stdout = typeof output === "string" ? output : typeof output?.stdout === "string" ? output.stdout : "";
+            return {
+              ok: result2?.ok === true,
+              stdout,
+              exitCode: typeof result2?.exitCode === "number" ? result2.exitCode : null
+            };
+          });
+          inFlight = job.catch(() => void 0);
+          return job;
+        },
+        upload: async (localPath, remotePath) => {
+          const sent = await (deps.runSbx ?? defaultRunSbx)(
+            ["--cloud", "cp", "-L", localPath, `${row.sandbox}:${remotePath}`],
+            { timeoutMs: 10 * 6e4 }
+          );
+          if (sent.exitCode === 0) return { ok: true, detail: "copied" };
+          const stderr = String(sent.stderr ?? "").slice(0, 200);
+          return { ok: false, detail: `sbx cp exit ${String(sent.exitCode)}${stderr ? `: ${stderr}` : ""}` };
+        }
+      };
+      const result = await body(workload, runtime);
+      completed = true;
+      return result;
+    } finally {
+      active = false;
+      await inFlight;
+      if (mayHaveSandbox) {
+        this.db.query("UPDATE docker_runs SET state='cleanup_pending' WHERE runId=?").run(runId);
+        if (lease === void 0) {
+          this.audit(runId, authenticatedCaller, `cleanup-after-create-without-lease:${prepareFailureCode ?? "unknown"}`, binding);
+        }
+        const releaseTarget = lease ?? {
+          leaseId: row.sandbox,
+          backendId: DOCKER_SANDBOX_BACKEND_ID,
+          ticketId: ticket.ticketId,
+          grantId: ticket.grantId,
+          createdAt: Date.now(),
+          readableRoots: [],
+          writableRoots: [],
+          metadata: { sandboxName: row.sandbox, leaseRecoveredBeforeHandoff: true }
+        };
+        if (backend) {
+          try {
+            await backend.release(releaseTarget, signal?.aborted ? "cancelled" : completed ? "completed" : "failed");
+          } catch {
+          }
+        }
+        try {
+          await this.stopAndConfirm(row);
+        } catch (cleanupError) {
+          const detail = cleanupError instanceof Error ? cleanupError.message : String(cleanupError);
+          this.audit(runId, authenticatedCaller, `cleanup_pending_unverified:${detail}`, binding);
+          console.warn(`[dockerWorkloadLifecycle] cleanup_pending run=${runId} sandbox=${row.sandbox}: ${detail}`);
+          if (!bodyReached || completed) throw cleanupError;
+        }
+      } else {
+        this.db.query("UPDATE docker_runs SET state='released', cleanupPending=0 WHERE runId=? AND state!='released'").run(runId);
+        this.audit(runId, authenticatedCaller, `prepare-failed-released:${prepareFailureCode ?? "unknown"}`, binding);
+      }
+    }
+  }
+};
+export {
+  DEFAULT_MAX_ACTIVE_RUNS_PER_ACCOUNT,
+  DockerWorkloadLifecycle,
+  createDockerBindingAuthorizer,
+  createTrustedDockerBindingAuthorizer,
+  getTrustedDockerBindings,
+  resolveMaxActiveRunsPerAccount,
+  shQuote
+};

package/action-GI44T4DR.js

@@ -1,31 +0,0 @@
-import {
-  shareResourceAction
-} from "./chunk-CU3QB4HW.js";
-import "./chunk-SONWNI3L.js";
-import "./chunk-Y5GCAMGP.js";
-import "./chunk-QDSINZM3.js";
-import "./chunk-KX6YBIHG.js";
-import "./chunk-HYZIYH2H.js";
-import "./chunk-7CHC4W22.js";
-import "./chunk-3AH7LNUB.js";
-import "./chunk-WWC7I6TA.js";
-import "./chunk-QSJ3HFEF.js";
-import "./chunk-IAESIMK7.js";
-import "./chunk-WIWM4FE3.js";
-import "./chunk-QOKAKDPE.js";
-import "./chunk-SEJ5OS6F.js";
-import "./chunk-OW765XBU.js";
-import "./chunk-GBRG75BQ.js";
-import "./chunk-KUG52IAP.js";
-import "./chunk-BNGW5ASC.js";
-import "./chunk-M2EJHDJP.js";
-import "./chunk-3EUW3WEO.js";
-import "./chunk-U6VC4MU4.js";
-import "./chunk-LCBAMY2M.js";
-import "./chunk-4SN6J65J.js";
-import "./chunk-CF7PE763.js";
-import "./chunk-G3SUCT4W.js";
-import "./chunk-4VNS5WPM.js";
-export {
-  shareResourceAction
-};