deepline 0.3.408 → 0.3.410

package/dist/cli/chunk-T44IIOT6.mjs

@@ -0,0 +1,501 @@
+import {
+  DEFAULT_SDK_SKILL_NAMES,
+  LEGACY_SKILL_NAMES_TO_REMOVE,
+  SKILLS_AUTO_SYNC_COMMAND,
+  SKILLS_NPX_PACKAGE,
+  SkillsStateUnavailableError,
+  acquireSkillsInstallLease,
+  clearFailedAutomaticSkillsSync,
+  hasFailedAutomaticSkillsSync,
+  resolveShellSpawn,
+  skillsInstallLeasePath,
+  skillsSourceUrl,
+  syncSdkSkillsIfNeeded
+} from "./chunk-XIHWSXSV.mjs";
+import {
+  printCommandEnvelope
+} from "./chunk-5V5Y37BC.mjs";
+import {
+  SDK_VERSION,
+  autoDetectBaseUrl,
+  detectAgentRuntime,
+  ensureProjectPrivatePathsIgnored,
+  resolveProjectPinTarget,
+  sdkCliStateDirPath
+} from "./chunk-RFB25DSQ.mjs";
+
+// src/cli/commands/skills.ts
+import { spawn } from "child_process";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname, join } from "path";
+var SKILLS_INSTALL_LEASE_WAIT_MS = 9e4;
+var SKILLS_PROCESS_TIMEOUT_MS = 45e3;
+var RUNTIME_TO_SKILLS_AGENT = {
+  antigravity: "antigravity",
+  claude_code: "claude-code",
+  claude_cowork: "claude-code",
+  cline: "cline",
+  codex: "codex",
+  cursor: "cursor",
+  gemini: "gemini-cli",
+  windsurf: "windsurf"
+};
+var AGENT_MARKERS = [
+  { agent: "codex", paths: [".codex"] },
+  { agent: "claude-code", paths: [".claude"] },
+  { agent: "cursor", paths: [".cursor"] },
+  { agent: "gemini-cli", paths: [".gemini", ".gemini-cli"] },
+  { agent: "antigravity", paths: [".antigravity"] }
+];
+var WORKSPACE_SKILL_ROOTS_BY_AGENT = {
+  antigravity: [".agents"],
+  "claude-code": [".claude"],
+  cline: [".agents"],
+  codex: [".agents"],
+  cursor: [".agents"],
+  "gemini-cli": [".agents"],
+  windsurf: [".windsurf"],
+  "*": [".agents", ".claude", ".windsurf"]
+};
+function workspaceSkillRootsForAgents(agents) {
+  return [
+    ...new Set(
+      agents.flatMap((agent) => WORKSPACE_SKILL_ROOTS_BY_AGENT[agent] ?? [])
+    )
+  ].sort((a, b) => a.localeCompare(b));
+}
+function normalizeScope(value) {
+  if (value === "global") return "global";
+  if (value === "local") return "local";
+  if (!value) return inferActiveSkillsScope();
+  throw new Error("--scope must be one of: global, local");
+}
+function inferActiveSkillsScope(entrypoint = process.argv[1] ?? "") {
+  return /[\\/]\.deepline[\\/]runtime[\\/]/.test(entrypoint) ? "local" : "global";
+}
+function resolveLocalRoot() {
+  const target = resolveProjectPinTarget();
+  if (!target.ok) {
+    throw new Error(
+      `Cowork project folder is ambiguous. Candidate folders: ${target.candidates.join(
+        ", "
+      )}. Set CLAUDE_PROJECT_DIR or cd into the intended project folder.`
+    );
+  }
+  return target.dir;
+}
+function detectSkillsAgents(input) {
+  const runtime = input.runtime ?? detectAgentRuntime();
+  const knownAgent = RUNTIME_TO_SKILLS_AGENT[runtime];
+  if (knownAgent) return [knownAgent];
+  const roots = [
+    ...input.scope === "local" && input.root ? [input.root] : [],
+    input.homeDir ?? homedir()
+  ];
+  const detected = AGENT_MARKERS.filter(
+    (marker) => roots.some(
+      (root) => marker.paths.some((path) => existsSync(join(root, path)))
+    )
+  ).map((marker) => marker.agent);
+  return detected.length > 0 ? detected : ["*"];
+}
+function skillsStatePathForScope(baseUrl, scope, root) {
+  return scope === "local" && root ? join(root, ".deepline", "setup", "skills.json") : join(sdkCliStateDirPath(baseUrl), "skills-install.json");
+}
+function buildSkillsPlan(input) {
+  const scopeArgs = input.scope === "global" ? ["--global"] : [];
+  const legacyNames = [...LEGACY_SKILL_NAMES_TO_REMOVE].sort(
+    (a, b) => a.localeCompare(b)
+  );
+  return {
+    scope: input.scope,
+    root: input.root,
+    agents: input.agents,
+    skillNames: input.skillNames,
+    version: input.version,
+    remove: {
+      command: "npm",
+      args: [
+        "exec",
+        "--yes",
+        `--package=${SKILLS_NPX_PACKAGE}`,
+        "--",
+        "skills",
+        "remove",
+        ...scopeArgs,
+        "--agent",
+        ...input.agents,
+        "-y",
+        ...legacyNames
+      ]
+    },
+    install: {
+      command: "npm",
+      args: [
+        "exec",
+        "--yes",
+        `--package=${SKILLS_NPX_PACKAGE}`,
+        "--",
+        "skills",
+        "add",
+        skillsSourceUrl(input.baseUrl),
+        "--agent",
+        ...input.agents,
+        ...scopeArgs,
+        "--yes",
+        ...input.skillNames.flatMap((name) => ["--skill", name]),
+        "--full-depth"
+      ]
+    },
+    statePath: skillsStatePathForScope(input.baseUrl, input.scope, input.root)
+  };
+}
+function sortedStrings(value) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    return null;
+  }
+  return [...value].sort((a, b) => a.localeCompare(b));
+}
+function isSkillsPlanCurrent(plan, state) {
+  if (!state || state.scope !== plan.scope || state.skillsVersion !== plan.version) {
+    return false;
+  }
+  const installedAgents = sortedStrings(state.agents);
+  const installedSkillNames = sortedStrings(state.skillNames);
+  if (!installedAgents || !installedSkillNames) return false;
+  return installedAgents.join("\0") === [...plan.agents].sort((a, b) => a.localeCompare(b)).join("\0") && installedSkillNames.join("\0") === [...plan.skillNames].sort((a, b) => a.localeCompare(b)).join("\0");
+}
+function readSkillsInstallState(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+function runProcess(command, args, cwd) {
+  return new Promise((resolve, reject) => {
+    const plan = resolveShellSpawn(
+      command,
+      args,
+      process.platform,
+      process.env,
+      cwd
+    );
+    const child = spawn(plan.command, plan.args, {
+      cwd,
+      env: process.env,
+      stdio: ["ignore", "ignore", "pipe"],
+      shell: plan.shell
+    });
+    let stderr = "";
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+      process.stderr.write(chunk);
+    });
+    const timeout = setTimeout(() => {
+      child.kill("SIGTERM");
+      reject(
+        new Error(
+          `${SKILLS_NPX_PACKAGE} timed out after ${SKILLS_PROCESS_TIMEOUT_MS}ms.`
+        )
+      );
+    }, SKILLS_PROCESS_TIMEOUT_MS);
+    child.once("error", (error) => {
+      clearTimeout(timeout);
+      reject(error);
+    });
+    child.once("close", (code) => {
+      clearTimeout(timeout);
+      if (code && stderr.trim()) {
+        process.stderr.write(`${SKILLS_NPX_PACKAGE} exited ${code}.
+`);
+      }
+      resolve(code ?? 1);
+    });
+  });
+}
+async function runSkillsCommand(options, dependencies = {}) {
+  let scope;
+  let root;
+  try {
+    scope = normalizeScope(options.scope);
+    root = scope === "local" ? resolveLocalRoot() : null;
+  } catch (error) {
+    printCommandEnvelope(
+      {
+        ok: false,
+        status: "failed",
+        code: "INVALID_SKILLS_SCOPE",
+        exitCode: 2,
+        message: error instanceof Error ? error.message : String(error)
+      },
+      { json: options.json }
+    );
+    return 2;
+  }
+  const baseUrl = autoDetectBaseUrl().replace(/\/$/, "");
+  const catalog = {
+    skillNames: [...DEFAULT_SDK_SKILL_NAMES],
+    version: SDK_VERSION
+  };
+  const agents = options.agent ? [options.agent] : detectSkillsAgents({ scope, root });
+  const plan = buildSkillsPlan({ baseUrl, scope, root, agents, ...catalog });
+  if (options.dryRun) {
+    printCommandEnvelope(
+      { ok: true, status: "planned", dryRun: true, ...plan },
+      { json: options.json }
+    );
+    return 0;
+  }
+  if (isSkillsPlanCurrent(plan, readSkillsInstallState(plan.statePath)) && !hasFailedAutomaticSkillsSync(baseUrl, agents)) {
+    printCommandEnvelope(
+      {
+        ok: true,
+        status: "current",
+        complete: true,
+        changed: false,
+        skipped: true,
+        skipReason: "skills_version_current",
+        scope,
+        agents,
+        skillsVersion: plan.version,
+        skillCount: plan.skillNames.length,
+        statePath: plan.statePath,
+        render: {
+          sections: [
+            {
+              title: "skills",
+              lines: [
+                `Scope: ${scope}`,
+                `Agents: ${agents.join(", ")}`,
+                `Current: ${plan.skillNames.length}`
+              ]
+            }
+          ]
+        }
+      },
+      { json: options.json }
+    );
+    return 0;
+  }
+  if (scope === "local" && root) {
+    const managedNames = [
+      .../* @__PURE__ */ new Set([...plan.skillNames, ...LEGACY_SKILL_NAMES_TO_REMOVE])
+    ];
+    const agentRoots = workspaceSkillRootsForAgents(plan.agents);
+    ensureProjectPrivatePathsIgnored(root, [
+      ".deepline/",
+      ...agentRoots.flatMap(
+        (agentRoot) => managedNames.map((name) => `${agentRoot}/skills/${name}/`)
+      )
+    ]);
+  }
+  let lease;
+  try {
+    lease = scope === "global" ? await acquireSkillsInstallLease(baseUrl, agents, plan.version, {
+      waitMs: dependencies.installLeaseWaitMs ?? SKILLS_INSTALL_LEASE_WAIT_MS,
+      onWait: () => process.stderr.write(
+        "Waiting for a background Deepline skills refresh to finish...\n"
+      )
+    }) : { release: () => {
+    } };
+  } catch (error) {
+    if (!(error instanceof SkillsStateUnavailableError)) throw error;
+    printCommandEnvelope(
+      {
+        ok: false,
+        status: "failed",
+        code: "SKILLS_STATE_UNAVAILABLE",
+        exitCode: 5,
+        scope,
+        agents,
+        message: error.message,
+        next: `Resolve this filesystem error, then run: deepline skills --scope ${scope}`
+      },
+      { json: options.json }
+    );
+    return 5;
+  }
+  if (!lease) {
+    printCommandEnvelope(
+      {
+        ok: false,
+        status: "failed",
+        code: "SKILLS_SYNC_IN_PROGRESS",
+        exitCode: 7,
+        scope,
+        agents,
+        message: "A background Deepline skills refresh is still running for these agents.",
+        next: `Retry in a moment: deepline skills --scope ${scope}. If no refresh is running, remove ${skillsInstallLeasePath(baseUrl, agents)}`
+      },
+      { json: options.json }
+    );
+    return 7;
+  }
+  try {
+    return await runSkillsInstallWithLease({
+      options,
+      dependencies,
+      baseUrl,
+      scope,
+      root,
+      agents,
+      plan
+    });
+  } finally {
+    lease.release();
+  }
+}
+async function runSkillsInstallWithLease(input) {
+  const { options, dependencies, baseUrl, scope, root, agents, plan } = input;
+  process.stderr.write(
+    `Replacing Deepline skills for ${agents.join(", ")} (${scope})...
+`
+  );
+  const execute = dependencies.runProcess ?? runProcess;
+  try {
+    const installCode = await execute(
+      plan.install.command,
+      plan.install.args,
+      root ?? void 0
+    );
+    if (installCode !== 0) {
+      throw new Error("Could not install the current Deepline skills.");
+    }
+  } catch (error) {
+    printCommandEnvelope(
+      {
+        ok: false,
+        status: "failed",
+        code: "SKILLS_INSTALL_FAILED",
+        exitCode: 5,
+        scope,
+        agents,
+        message: error instanceof Error ? error.message : String(error),
+        next: `deepline skills --scope ${scope}`
+      },
+      { json: options.json }
+    );
+    return 5;
+  }
+  try {
+    const removeCode = await execute(
+      plan.remove.command,
+      plan.remove.args,
+      root ?? void 0
+    );
+    if (removeCode !== 0) {
+      process.stderr.write(
+        "Current Deepline skills installed, but legacy skill cleanup failed. The installed skills remain usable.\n"
+      );
+    }
+  } catch (error) {
+    process.stderr.write(
+      `Current Deepline skills installed, but legacy skill cleanup failed: ${error instanceof Error ? error.message : String(error)}. The installed skills remain usable.
+`
+    );
+  }
+  mkdirSync(dirname(plan.statePath), { recursive: true });
+  writeFileSync(
+    plan.statePath,
+    `${JSON.stringify(
+      {
+        schemaVersion: 1,
+        installedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        cliVersion: SDK_VERSION,
+        scope,
+        agents,
+        skillsVersion: plan.version,
+        skillNames: plan.skillNames
+      },
+      null,
+      2
+    )}
+`,
+    "utf8"
+  );
+  if (scope === "global") {
+    clearFailedAutomaticSkillsSync(baseUrl, agents);
+  }
+  printCommandEnvelope(
+    {
+      ok: true,
+      status: "complete",
+      scope,
+      agents,
+      skillsVersion: plan.version,
+      skillCount: plan.skillNames.length,
+      statePath: plan.statePath,
+      render: {
+        sections: [
+          {
+            title: "skills",
+            lines: [
+              `Scope: ${scope}`,
+              `Agents: ${agents.join(", ")}`,
+              `Installed: ${plan.skillNames.length}`
+            ]
+          }
+        ]
+      }
+    },
+    { json: options.json }
+  );
+  return 0;
+}
+function registerSkillsCommand(program) {
+  program.command("skills").description("Replace Deepline agent skills with the current release.").option("--scope <scope>", "Install scope: global or local").option("--agent <agent>", "Override the detected agent target").option("--dry-run", "Print the install plan without changing files").option("--json", "Emit one JSON result envelope").addHelpText(
+    "after",
+    `
+Notes:
+  This command reinstalls current Deepline-managed skills using ${SKILLS_NPX_PACKAGE},
+  then removes legacy Deepline skill names. Local scope writes into the resolved
+  persistent project.
+
+Examples:
+  deepline skills
+  deepline skills --scope local
+  deepline skills --agent codex --dry-run
+`
+  ).action(async (options) => {
+    process.exitCode = await runSkillsCommand(options);
+  });
+  program.command(SKILLS_AUTO_SYNC_COMMAND, { hidden: true }).description("Refresh Deepline agent skills in the background.").option(
+    "--claim <token>",
+    "Owner token of the leases this child was started for."
+  ).action(async (options) => {
+    const claim = options.claim?.trim();
+    if (!claim) {
+      printCommandEnvelope(
+        {
+          ok: false,
+          status: "failed",
+          code: "SKILLS_AUTO_SYNC_CLAIM_REQUIRED",
+          exitCode: 2,
+          message: "skills-auto-sync is started by ordinary deepline commands and requires the lease token they pass; run `deepline skills` to install skills yourself."
+        },
+        { json: true }
+      );
+      process.exitCode = 2;
+      return;
+    }
+    await syncSdkSkillsIfNeeded(autoDetectBaseUrl().replace(/\/$/, ""), {
+      mode: "inline",
+      notices: "defer",
+      claim
+    });
+  });
+}
+
+export {
+  workspaceSkillRootsForAgents,
+  inferActiveSkillsScope,
+  detectSkillsAgents,
+  skillsStatePathForScope,
+  buildSkillsPlan,
+  isSkillsPlanCurrent,
+  runSkillsCommand,
+  registerSkillsCommand
+};

package/dist/cli/chunk-VK2LZ5IP.js

@@ -0,0 +1,35 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkOBB4QXHAjs = require('./chunk-OBB4QXHA.js');
+
+
+
+
+var _chunkLTFL4JRNjs = require('./chunk-LTFL4JRN.js');
+
+// src/cli/play-run-admission.ts
+function usesInlinePlayAdmission(command, args) {
+  return command === "plays run" && args.includes("--json") && !args.includes("--no-wait") && !args.some(
+    (arg) => arg === "--run-id-file" || arg.startsWith("--run-id-file=")
+  );
+}
+async function checkPlayRunCompatibility(baseUrl, maintenancePolicy = "configured") {
+  if (maintenancePolicy !== "off") _chunkLTFL4JRNjs.flushDeferredSkillsSyncNotices.call(void 0, baseUrl);
+  const compatibility = await _chunkOBB4QXHAjs.traceCliSpan.call(void 0, 
+    "cli.sdk_compatibility",
+    { baseUrl, command: "plays run" },
+    () => _chunkLTFL4JRNjs.checkSdkCompatibility.call(void 0, baseUrl, {
+      command: "plays run",
+      persistCache: maintenancePolicy !== "off"
+    })
+  );
+  if (compatibility.error) throw compatibility.error;
+  _chunkLTFL4JRNjs.enforceSdkCompatibilityResponse.call(void 0, compatibility.response, {
+    quietAdvisory: true
+  });
+}
+
+
+
+
+exports.usesInlinePlayAdmission = usesInlinePlayAdmission; exports.checkPlayRunCompatibility = checkPlayRunCompatibility;

package/dist/cli/chunk-VKKVSFRD.js

@@ -0,0 +1,62 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); var _class; var _class2;// ../plays/fetch-http-error.ts
+var CtxFetchHttpError = (_class = class extends Error {
+  /** Build the error from the durable response record. */
+  constructor(response) {
+    const body = response.bodyText || "empty response body";
+    super(
+      `ctx.fetch(${response.url}) returned HTTP ${response.status}${response.statusText ? ` ${response.statusText}` : ""}: ${body}`
+    );_class.prototype.__init.call(this);;
+    this.response = response;
+    this.name = "CtxFetchHttpError";
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.url = response.url;
+    this.headers = response.headers;
+    this.bodyText = response.bodyText;
+    this.json = response.json;
+  }
+  /**
+   * Play source and the runtime are separately bundled. Recognize the stable
+   * public error code so `instanceof` works across that boundary as well.
+   */
+  static [Symbol.hasInstance](value) {
+    return value !== null && typeof value === "object" && value.code === "CTX_FETCH_HTTP_ERROR";
+  }
+  /** Stable machine-readable HTTP-failure code. */
+  __init() {this.code = "CTX_FETCH_HTTP_ERROR"}
+  /** Upstream HTTP status. */
+  
+  /** Upstream HTTP status text. */
+  
+  /** Final response URL after redirects. */
+  
+  /** Secret-redacted response headers. */
+  
+  /** Complete secret-redacted response body. */
+  
+  /** Eagerly parsed secret-redacted JSON, or null. */
+  
+}, _class);
+
+// ../plays/ambiguous-write-error.ts
+var CtxFetchAmbiguousWriteError = (_class2 = class extends Error {
+  constructor(method, origin, options) {
+    super(
+      `ctx.fetch ${method} to ${origin} was dispatched, but its outcome is unknown. Reconcile with the provider or retry only under its supported idempotency contract using the same intended-operation key.`,
+      options
+    );_class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);;
+    this.method = method;
+    this.origin = origin;
+    this.name = "CtxFetchAmbiguousWriteError";
+  }
+  static [Symbol.hasInstance](value) {
+    return value !== null && typeof value === "object" && value.code === "CTX_FETCH_WRITE_OUTCOME_UNKNOWN";
+  }
+  __init2() {this.code = "CTX_FETCH_WRITE_OUTCOME_UNKNOWN"}
+  __init3() {this.outcome = "unknown"}
+}, _class2);
+
+
+
+
+exports.CtxFetchHttpError = CtxFetchHttpError; exports.CtxFetchAmbiguousWriteError = CtxFetchAmbiguousWriteError;