dsh-loop-engine-allinone 0.0.0-stage → 0.4.0

package/lib/invariant.js

@@ -0,0 +1,453 @@
+// src/settings.ts
+import z from "@deepseek-ai/schemastery";
+
+// src/engine-registry.ts
+var HOSTED_ENGINE_IDS = [
+  "claude-code",
+  "codex",
+  "pi",
+  "kimi",
+  "agy",
+  "zcode",
+  "qoderclicn",
+  "hermes",
+  "grok",
+  "minimaxcode"
+];
+var LOOP_ENGINE_IDS = ["in-process", ...HOSTED_ENGINE_IDS];
+var ENGINE_REGISTRY = {
+  "claude-code": {
+    id: "claude-code",
+    label: "Claude Code",
+    repo: "https://github.com/anthropics/claude-code",
+    // The SDK is an npm dependency, but its `pathToClaudeCodeExecutable` option
+    // hands the work to an external binary, so the deployment may unbind it.
+    bundled: true,
+    binConfigKey: "claudeBin",
+    versionArgv: ["--version"],
+    loginHint: "run `claude` once and sign in, or point `claudeBin` at a signed-in install",
+    authPaths: [".claude/.credentials.json", ".claude.json"],
+    localeKey: "engineClaudeCode",
+    capabilities: {
+      streaming: true,
+      // The Agent SDK delivers an async message stream; the driver reads it as
+      // frames, which is the ndjson family's shape.
+      protocol: "ndjson",
+      sessionResume: true,
+      permissionModes: ["default", "acceptEdits", "bypassPermissions", "plan"],
+      images: true,
+      reasoningLevels: false
+    }
+  },
+  codex: {
+    id: "codex",
+    label: "Codex",
+    repo: "https://github.com/openai/codex",
+    bundled: true,
+    binConfigKey: "codexBin",
+    versionArgv: ["--version"],
+    loginHint: "run `codex login`, or set CODEX_API_KEY, or point `codexBin` at a signed-in install",
+    authPaths: [".codex/auth.json"],
+    localeKey: "engineCodex",
+    capabilities: {
+      streaming: true,
+      protocol: "jsonrpc",
+      sessionResume: true,
+      // Codex declares its stance as a (sandbox mode, approval policy) PAIR at
+      // `thread/start`, so the modes are the sandbox half.
+      permissionModes: ["read-only", "workspace-write", "danger-full-access"],
+      images: true,
+      reasoningLevels: true
+    }
+  },
+  pi: {
+    id: "pi",
+    label: "Pi",
+    repo: "https://github.com/earendil-works/pi",
+    bundled: true,
+    binConfigKey: "piBin",
+    versionArgv: ["--version"],
+    loginHint: "run `pi` once and sign in, or set the provider API-key variable pi expects",
+    authPaths: [".pi/agent/auth.json"],
+    localeKey: "enginePi",
+    capabilities: {
+      streaming: true,
+      protocol: "jsonrpc",
+      // Every step opens a fresh `pi --mode rpc` session, so there is no id to
+      // resume across launches.
+      sessionResume: false,
+      permissionModes: ["read-only", "workspace-write", "danger-full-access"],
+      images: true,
+      reasoningLevels: true
+    }
+  },
+  kimi: {
+    id: "kimi",
+    label: "Kimi Code",
+    repo: "https://github.com/MoonshotAI/kimi-cli",
+    bundled: false,
+    binConfigKey: "kimiBin",
+    versionArgv: ["--version"],
+    updateArgv: ["update"],
+    loginHint: "run `kimi` once and sign in (or `kimi login`)",
+    authPaths: [".kimi-code/credentials.json", ".kimi-code/auth.json"],
+    localeKey: "engineKimi",
+    capabilities: {
+      streaming: true,
+      protocol: "acp",
+      sessionResume: true,
+      permissionModes: ["ask", "allow", "deny"],
+      images: true,
+      reasoningLevels: false
+    }
+  },
+  agy: {
+    id: "agy",
+    label: "Antigravity",
+    repo: "https://antigravity.google",
+    bundled: false,
+    binConfigKey: "agyBin",
+    versionArgv: ["--version"],
+    updateArgv: ["update"],
+    loginHint: "run `agy` once and complete the Google sign-in it opens",
+    authPaths: [".gemini/oauth_creds.json"],
+    localeKey: "engineAgy",
+    // Verified with `agy models` on a signed-in host (2026-10-17) and confirmed
+    // selectable end to end: `--model gemini-3.8-flash-low` answered PONG.
+    models: [
+      { id: "gemini-3.8-flash-high", label: "Gemini 3.8 Flash (High)" },
+      { id: "gemini-3.8-flash-medium", label: "Gemini 3.8 Flash (Medium)" },
+      { id: "gemini-3.8-flash-low", label: "Gemini 3.8 Flash (Low)" },
+      { id: "claude-sonnet-4-6", label: "Claude Sonnet 4.6 (Thinking)" },
+      { id: "claude-opus-4-6-thinking", label: "Claude Opus 4.6 (Thinking)" },
+      { id: "gpt-oss-120b-medium", label: "GPT-OSS 120B (Medium)" }
+    ],
+    capabilities: {
+      // VERIFIED against a signed-in host: `step_update` frames carry
+      // `text_delta` increments, and the driver maps them (see
+      // `engine-agy/frames.ts`).
+      streaming: true,
+      protocol: "ndjson",
+      // The CLI continues a conversation with `--conversation <id>` and reports
+      // the id it used, but this driver does NOT use it: the plugin is stateless
+      // by design, replaying the durable transcript into every step, so there is
+      // nothing to carry across steps and nothing that could leak between them.
+      sessionResume: true,
+      // The CLI's EXECUTION modes. They are deliberately not treated as the
+      // permission switch: `--mode accept-edits` and `--mode plan` were both
+      // verified to leave `permission_mode` at `request-review`. What actually
+      // gates tools headless is `--dangerously-skip-permissions`, mapped from
+      // dsh's sandbox knob (`agyDangerouslySkipPermissions`).
+      permissionModes: ["accept-edits", "auto", "plan"],
+      // Verified absent: there is no image input on this surface.
+      images: false,
+      reasoningLevels: true
+    }
+  },
+  zcode: {
+    id: "zcode",
+    label: "ZCode",
+    repo: "https://z.ai",
+    bundled: false,
+    binConfigKey: "zcodeBin",
+    versionArgv: ["version"],
+    updateArgv: ["plugins", "update"],
+    loginHint: "run `zcode login` to sign in with Z.AI",
+    authPaths: [".zcode/v2", ".zcode/cli"],
+    localeKey: "engineZcode",
+    capabilities: {
+      streaming: true,
+      protocol: "jsonrpc",
+      sessionResume: true,
+      permissionModes: ["build", "edit", "plan", "yolo"],
+      images: false,
+      reasoningLevels: false
+    }
+  },
+  qoderclicn: {
+    id: "qoderclicn",
+    label: "Qoder CN",
+    repo: "https://qoder.com",
+    bundled: false,
+    binConfigKey: "qoderclicnBin",
+    versionArgv: ["--version"],
+    updateArgv: ["update"],
+    loginHint: "run `qoderclicn login` to sign in to Qoder CN",
+    authPaths: [".qoder-cn/.auth/user"],
+    localeKey: "engineQoderclicn",
+    capabilities: {
+      streaming: true,
+      // `-p --output-format stream-json` emits Claude Code's stream-json frames,
+      // one JSON document per line.
+      protocol: "ndjson",
+      sessionResume: true,
+      permissionModes: ["default", "accept_edits", "bypass_permissions", "dont_ask", "auto"],
+      // `--attachment` takes files, but a probe could not confirm image blocks
+      // survive the round trip, so the engine does not claim the capability.
+      images: false,
+      reasoningLevels: true
+    }
+  },
+  hermes: {
+    id: "hermes",
+    label: "Hermes Agent",
+    repo: "https://github.com/NousResearch/hermes",
+    bundled: false,
+    binConfigKey: "hermesBin",
+    versionArgv: ["--version"],
+    updateArgv: ["update"],
+    loginHint: "run `hermes setup` (or `hermes auth`) to sign in to an inference provider",
+    authPaths: ["auth.json"],
+    localeKey: "engineHermes",
+    capabilities: {
+      // `-z PROMPT` prints the finished answer; a probe found no structured
+      // stream, so the driver reads the whole of stdout as one reply.
+      streaming: false,
+      protocol: "text",
+      sessionResume: true,
+      permissionModes: ["safe-mode", "yolo"],
+      images: false,
+      reasoningLevels: true
+    }
+  },
+  grok: {
+    id: "grok",
+    label: "Grok Build",
+    repo: "https://github.com/xai-org/grok-build",
+    bundled: false,
+    binConfigKey: "grokBin",
+    versionArgv: ["--version"],
+    // Verified against the released binary (1.0.59): `grok update  Check for
+    // updates or install a specific version`. The vendor's own installer
+    // (`x.ai/cli/install.sh`) is the other upgrade path and reinstalls in place.
+    updateArgv: ["update"],
+    loginHint: "run `grok` once and complete the sign-in it opens (or `grok login`), then retry",
+    authPaths: [".grok/auth.json"],
+    localeKey: "engineGrok",
+    // Measured from the SIGNED-IN agent's own `initialize` answer
+    // (`_meta.modelState`): the catalog it will actually serve, whose
+    // `currentModelId` is `grok-4.7`. This REPLACED an earlier list taken from
+    // the unauthenticated `grok models` command, which reported `grok-4.6` and
+    // `grok-4.5` — ids the ACP surface then rejected with `-32602 unknown model
+    // id`. The lesson is the fork's own rule: a catalog is read from the surface
+    // the driver talks to, not from a sibling command that may be reading a
+    // different source.
+    models: [
+      { id: "grok-4.7", label: "Grok 4.7" }
+    ],
+    capabilities: {
+      // Measured: `session/update` frames carry `agent_message_chunk` and
+      // `agent_thought_chunk` increments.
+      streaming: true,
+      protocol: "acp",
+      // Measured: `initialize` answers `loadSession: true` with
+      // `sessionCapabilities.resume`, and the user guide documents
+      // `session/load` plus headless `--resume`/`--continue`.
+      sessionResume: true,
+      // The ACP gate is `session/request_permission`, and this engine's own
+      // always-approve switch is the `--always-approve` argv flag (alias
+      // `--yolo`), which `session/new` can also express as `_meta.yoloMode`.
+      permissionModes: ["ask", "always-approve"],
+      // Measured: `initialize` answers `promptCapabilities.image: false`, so the
+      // driver keeps images as path-bearing placeholders instead of sending
+      // blocks this engine would refuse.
+      images: false,
+      // The user guide documents the `reasoning_effort` session config option
+      // (`minimal`, `low`, `medium`, `high`, `xhigh`).
+      reasoningLevels: true,
+      // Measured: the engine answers `protocolVersion: 1` to a client that
+      // announces 1.
+      acpProtocolVersion: 1
+    }
+  },
+  minimaxcode: {
+    id: "minimaxcode",
+    label: "MiniMax Code",
+    // The vendor's documentation site; the GitHub org (`github.com/MiniMax-AI`)
+    // publishes no CLI repository for this product.
+    repo: "https://agent.minimax.io/docs/cli/quick-start",
+    bundled: false,
+    binConfigKey: "minimaxcodeBin",
+    versionArgv: ["--version"],
+    // Verified against 0.6.12: `mcode update  Check for and install a Minimax
+    // Code update`.
+    updateArgv: ["update"],
+    // The subscription path is the whole point of this engine: signing in is what
+    // enables the M Plan allowance, and `provider use token-plan` is what makes
+    // the CLI spend it instead of an API key.
+    loginHint: "run `mcode login --region cn|global`, then `mcode provider use token-plan` to spend your M Plan subscription",
+    // Measured on this host: credentials live per REGION under
+    // `~/.minimax/auth/prod/<region>/mcode-public/auth.json`, and the CLI writes
+    // an `auth-state.json` beside them. The directory, not the file, is the
+    // "signed in at least once" fact.
+    authPaths: [".minimax/auth/prod"],
+    region: {
+      configKey: "mcodeRegion",
+      // MEASURED, and not the name one would guess: `MCODE_REGION` is INERT on
+      // the `mcode acp` path (a child with `MCODE_REGION=en` still authenticated
+      // as the `cn` account), while `MAVIS_REGION=en` flipped it to "auth
+      // required" — so `MAVIS_REGION` is the variable THIS surface honours. The
+      // `MCODE_*` family belongs to the CLI's Electron/mcode-tools broker, which
+      // is a different process. A driver that set `MCODE_REGION` would look
+      // correct and change nothing.
+      envVar: "MAVIS_REGION",
+      default: "cn",
+      // TWO vocabularies, and conflating them would set a value the CLI rejects:
+      // the LOGIN flag speaks `cn|global` (`mcode login --region cn|global`),
+      // while the region VALUE the runtime reads and validates is `cn|en`
+      // (shipped code: `i!=="cn"&&i!=="en"` throws "The MCode mcode-tools host
+      // environment is incomplete"; the same value picks the `zh`/`en` locale and
+      // the `mavis` endpoint host). So `en` is this knob's spelling of the
+      // non-China account, and the values below are the ones this variable
+      // accepts. Only `cn` was measurable here — this host's account is a `cn`
+      // one, and the `en` side was observed only as "the cn credentials no longer
+      // apply".
+      values: ["cn", "en"]
+    },
+    localeKey: "engineMinimaxcode",
+    // Measured from the live `session/new` answer (unauthenticated catalog):
+    // MiniMax Code's own composite model ids, whose `v:` suffix selects the
+    // variant. A subscription can expose more; a stale id fails loud at the
+    // engine, which is the honest outcome.
+    models: [
+      { id: "m:minimax:MiniMax-M3:v:thinking", label: "M3 \xB7 thinking" },
+      { id: "m:minimax:MiniMax-M3:v:", label: "M3" },
+      { id: "m:minimax:MiniMax-M3.1-Flash-Preview:v:thinking", label: "M3.1-Flash-Preview \xB7 thinking" },
+      { id: "m:minimax:MiniMax-M3.1-Flash-Preview:v:", label: "M3.1-Flash-Preview" },
+      { id: "m:minimax:MiniMax-M2.7-highspeed:v:thinking", label: "M2.7-highspeed \xB7 thinking" },
+      { id: "m:minimax:MiniMax-M2.7:v:thinking", label: "M2.7 \xB7 thinking" }
+    ],
+    capabilities: {
+      // Measured: `agent_message_chunk` / `agent_thought_chunk` increments, and
+      // the ACP handshake answered a real prompt with `stopReason: end_turn`.
+      streaming: true,
+      protocol: "acp",
+      // Measured: `loadSession: true`, `sessionCapabilities.resume`, and a real
+      // `session/load` was ACCEPTED on 0.6.12.
+      sessionResume: true,
+      // Measured from the live `session/new` configOptions: the engine's
+      // `permissionMode` option is exactly these three values.
+      permissionModes: ["default", "auto", "bypassPermissions"],
+      // Measured: `promptCapabilities.image: true` (and the engine's own catalog
+      // declares image/video modalities for the M3 models).
+      images: true,
+      // Measured: a `thinkingEffort` config option
+      // (`default`/`low`/`medium`/`high`/`xhigh`/`max`).
+      reasoningLevels: true,
+      // Measured: the engine answers `protocolVersion: 1`.
+      acpProtocolVersion: 1
+    }
+  }
+};
+var ENGINE_DESCRIPTORS = HOSTED_ENGINE_IDS.map((id) => ENGINE_REGISTRY[id]);
+
+// src/settings.ts
+var LOOP_ENGINE_SETTINGS_SCHEMA = z.object({
+  engine: z.union(LOOP_ENGINE_IDS.map((id) => z.const(id))).default("in-process"),
+  showInComposer: z.boolean().default(true),
+  showEngineBadge: z.boolean().default(true)
+});
+function withVolatile(schema) {
+  const volatile = schema.volatile;
+  return volatile === void 0 ? schema : volatile.call(schema);
+}
+var LOOP_ENGINE_ENGINE_SCHEMA = withVolatile(
+  z.union(LOOP_ENGINE_IDS.map((id) => z.const(id))).default("in-process")
+);
+var LOOP_ENGINE_SHOW_IN_COMPOSER_SCHEMA = withVolatile(z.boolean().default(true));
+var LOOP_ENGINE_SHOW_ENGINE_BADGE_SCHEMA = withVolatile(z.boolean().default(true));
+
+// src/patch-manager.ts
+var MANAGED_BLOCK_BEGIN = "# -- dsh-loop-engine managed block --";
+var LEGACY_MANAGED_BLOCK_BEGIN = "# -- dsh-loop-engine managed block: ";
+var MANAGED_BLOCK_END = "# -- /dsh-loop-engine managed block --";
+var END_MARKER_LINE = `${MANAGED_BLOCK_END}
+`;
+function renderManagedBlock() {
+  return [
+    MANAGED_BLOCK_BEGIN,
+    "- id: agent-loop",
+    "  disabled: true",
+    "- id: command-goal",
+    "  disabled: true",
+    END_MARKER_LINE
+  ].join("\n");
+}
+function hasManagedBlock(text) {
+  return text.includes("# -- dsh-loop-engine managed block");
+}
+var LEGACY_BEGIN_MARKER_RE = /^# -- dsh-loop-engine managed block: (\S+) --$/m;
+function legacyBlockEngineOf(text) {
+  const engine = LEGACY_BEGIN_MARKER_RE.exec(text)?.[1];
+  return LOOP_ENGINE_IDS.includes(engine ?? "") ? engine : void 0;
+}
+function managedSpan(text) {
+  const begin = text.indexOf("# -- dsh-loop-engine managed block");
+  if (begin === -1) return { head: text, tail: "", present: false, blankBefore: false };
+  const afterBegin = begin + LEGACY_MANAGED_BLOCK_BEGIN.length;
+  const endAt = text.indexOf(MANAGED_BLOCK_END, afterBegin);
+  const spanEnd = endAt === -1 ? text.length : endAt + END_MARKER_LINE.length;
+  const before = text.slice(0, begin);
+  const blankBefore = before.endsWith("\n\n");
+  return {
+    head: blankBefore ? before.slice(0, -1) : before,
+    tail: text.slice(spanEnd),
+    present: true,
+    blankBefore
+  };
+}
+function ensureTrailingNewline(text) {
+  return text.endsWith("\n") ? text : `${text}
+`;
+}
+function dropSeedPlaceholder(text) {
+  return text.replace(/^\[\]\n/m, "");
+}
+function applyManagedBlock(text) {
+  const block = renderManagedBlock();
+  const span = managedSpan(text);
+  if (!span.present) {
+    if (text === "") return block;
+    return dropSeedPlaceholder(`${ensureTrailingNewline(text)}
+${block}`);
+  }
+  return dropSeedPlaceholder(`${span.head}${span.blankBefore ? "\n" : ""}${block}${span.tail}`);
+}
+
+// src/invariant.ts
+var PACKAGE_NAME = "dsh-loop-engine-allinone";
+var name = "loop-engine-invariant";
+var inject = ["invariants"];
+var install = (ctx, fail) => {
+  void ctx;
+  const seed = "";
+  const commentOnly = "# dsh profile patch layer\n";
+  const applied = applyManagedBlock(seed);
+  if (applyManagedBlock(applied) !== applied) fail("the managed block is not a fixed point");
+  if (!hasManagedBlock(renderManagedBlock())) fail("the rendered block is not recognized by hasManagedBlock");
+  if (!applied.includes("- id: agent-loop")) fail("the managed block must disable the base agent-loop row");
+  if (legacyBlockEngineOf(applied) !== void 0) fail("the current block must not read as a legacy engine pin");
+  for (const engine of LOOP_ENGINE_IDS) {
+    const head = "# user patch layer\n";
+    const legacy = `${head}
+${LEGACY_MANAGED_BLOCK_BEGIN}${engine} --
+- id: agent-loop
+  disabled: true
+${MANAGED_BLOCK_END}
+`;
+    if (legacyBlockEngineOf(legacy) !== engine) fail(`a legacy ${engine} block must still read as the ${engine} pin`);
+    if (applyManagedBlock(legacy) !== applyManagedBlock(head)) {
+      fail(`a legacy ${engine} block must migrate to the current block`);
+    }
+  }
+  if (applyManagedBlock(commentOnly) === commentOnly) {
+    fail("a comment-only file must gain the block as its top-level array");
+  }
+};
+var apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+export {
+  apply,
+  inject,
+  name
+};
+//# sourceMappingURL=invariant.js.map