open-claude-p 1.1.2 → 1.2.1

package/src/options/parse-argv.js

@@ -26,15 +26,20 @@ import { OPTION_SPEC, getOption } from './spec.js';
  * @property {string[]} positional
  * @property {string[]} unknown      Tokens that look like flags but were not in the spec.
  * @property {string[]} errors       Human-readable error strings.
+ * @property {Set<string>} supplied  Canonical names actually present in argv.
+ *   Defaults are pre-seeded into `options`, so a value alone cannot tell
+ *   "user passed `--flag=false`" apart from "user passed nothing" — this
+ *   set is the only way to distinguish them.
  */
 
 /**
  * @param {string[]} argv
+ * @param {Record<string, string|undefined>} [env]  defaults to `process.env`
  * @returns {ParseResult}
  */
-export function parseArgv(argv) {
+export function parseArgv(argv, env = process.env) {
   /** @type {ParseResult} */
-  const out = { options: {}, positional: [], unknown: [], errors: [] };
+  const out = { options: {}, positional: [], unknown: [], errors: [], supplied: new Set() };
 
   // Pre-seed defaults so the validator sees them.
   for (const spec of OPTION_SPEC) {
@@ -43,6 +48,14 @@ export function parseArgv(argv) {
     }
   }
 
+  // Canonical names supplied on the command line. Used only by the
+  // env-var pass at the end: argv always wins over the environment, and
+  // that has to include an explicit opt-out like `--print-mode=false`,
+  // whose value is indistinguishable from the default if you compare
+  // values instead of tracking what was actually seen.
+  /** @type {Set<string>} */
+  const supplied = out.supplied;
+
   let i = 0;
   while (i < argv.length) {
     const tok = argv[i];
@@ -63,6 +76,7 @@ export function parseArgv(argv) {
         i++;
         continue;
       }
+      supplied.add(spec.name);
       i = consumeOption(spec, argv, i, inline, out);
       continue;
     }
@@ -93,11 +107,13 @@ export function parseArgv(argv) {
             );
             break;
           }
+          supplied.add(spec.name);
           i = consumeOption(spec, argv, i, undefined, out);
           consumedByValue = true;
           break;
         }
         // Boolean short: just set.
+        supplied.add(spec.name);
         out.options[spec.name] = true;
       }
       if (!consumedByValue) i++;
@@ -109,9 +125,64 @@ export function parseArgv(argv) {
     i++;
   }
 
+  applyEnvFallbacks(out, supplied, env);
+
   return out;
 }
 
+/**
+ * Fill in options that were not supplied on the command line from their
+ * declared `env:` variable.
+ *
+ * OPTION_SPEC has always documented an `env` field, but nothing read it —
+ * the two entries that used it (`--print-mode`, `--no-session-persistence`)
+ * were wired up by hand at their call sites instead, so any new entry that
+ * declared `env` silently did nothing. This makes the declaration real, and
+ * keeps the precedence the hand-rolled versions already used:
+ *
+ *   explicit argv  >  environment variable  >  spec default
+ *
+ * Booleans accept `1` / `true` / `yes` / `on` (case-insensitive); anything
+ * else, including the empty string, leaves the option at its default so
+ * `VAR=` and `VAR=0` both read as "off". Value-taking options are coerced
+ * through the same `coerce()` path as argv, and a malformed value produces
+ * the same style of error rather than being silently ignored.
+ *
+ * @param {ParseResult} out
+ * @param {Set<string>} supplied  canonical names seen on the command line
+ * @param {Record<string, string|undefined>} env
+ */
+function applyEnvFallbacks(out, supplied, env) {
+  for (const spec of OPTION_SPEC) {
+    if (!spec.env) continue;
+    const raw = Object.prototype.hasOwnProperty.call(env ?? {}, spec.env)
+      ? env[spec.env]
+      : undefined;
+    // Library callers can pass any object as `env`; only honour real
+    // string values so a stray number/object cannot throw in `.trim()`.
+    if (typeof raw !== 'string' || raw === '') continue;
+    // Supplied on the command line — argv always wins.
+    if (supplied.has(spec.name)) continue;
+
+    if (spec.kind === 'boolean') {
+      const v = raw.trim().toLowerCase();
+      if (v === '1' || v === 'true' || v === 'yes' || v === 'on') {
+        out.options[spec.name] = true;
+      }
+      continue;
+    }
+    if (spec.kind === 'array') {
+      // Comma-separated, so a single env var can carry a repeatable flag.
+      const items = raw.split(',').map((x) => x.trim()).filter(Boolean);
+      if (items.length > 0) out.options[spec.name] = items;
+      continue;
+    }
+    const { value, error } = coerce(spec, raw);
+    if (error) out.errors.push(`${spec.env}: ${error}`);
+    else out.options[spec.name] = value;
+  }
+}
+
 /**
  * Consume the value(s) for `spec` starting at argv index `i` (where argv[i]
  * is the flag token itself). `inline` is the post-`=` value when present.

package/src/options/spec.js

@@ -17,6 +17,9 @@
 //                   times (occurrences accumulate); array kind also collects
 //                   variadic values until the next flag-looking token.
 //     env:          Optional environment-variable fallback.
+//     printModeOnly: Only forward this flag when running under
+//                   `--print-mode`. For upstream flags that require
+//                   `--print` and abort the process without it.
 //     description:  One-line help text.
 //     forward:      How this option reaches the upstream `claude` process.
 //                     { type: 'argv', flag: '--name' }   pass to spawn argv
@@ -72,7 +75,11 @@ export const OPTION_SPEC = [
   {
     name: 'model',
     kind: 'string',
-    description: 'Model alias or full name (e.g. `sonnet`, `claude-sonnet-4-6`).',
+    description:
+      'Model alias or full name. Aliases resolve to the latest model in ' +
+      'that family (e.g. `fable`, `opus`, `sonnet`, `haiku`); full names ' +
+      'are passed through verbatim (e.g. `claude-opus-5`, ' +
+      '`claude-fable-5-1`, `claude-sonnet-5`).',
     forward: { type: 'argv', flag: '--model' },
   },
   {
@@ -225,6 +232,24 @@ export const OPTION_SPEC = [
       '(stream-json input + output only).',
     forward: { type: 'shim' },
   },
+  {
+    name: 'forward-subagent-text',
+    kind: 'boolean',
+    default: false,
+    description:
+      'Forward subagent text and thinking blocks as assistant/user messages ' +
+      'with `parent_tool_use_id` set. Requires `--output-format=stream-json`.',
+    forward: { type: 'argv', flag: '--forward-subagent-text' },
+  },
+  {
+    name: 'prompt-suggestions',
+    kind: 'boolean',
+    default: false,
+    description:
+      'Emit a `prompt_suggestion` message after each turn carrying a ' +
+      'predicted next user prompt (stream-json output).',
+    forward: { type: 'argv', flag: '--prompt-suggestions' },
+  },
   {
     name: 'include-hook-events',
     kind: 'boolean',
@@ -236,7 +261,18 @@ export const OPTION_SPEC = [
     name: 'include-partial-messages',
     kind: 'boolean',
     default: false,
-    description: 'Include partial assistant message chunks in stream-json output.',
+    // Upstream refuses this flag unless it is also given `--print`
+    // ("Error: --include-partial-messages requires --print and
+    // --output-format=stream-json") and exits immediately. The default
+    // PTY path drives the interactive TUI, so forwarding it there kills
+    // the spawn. ocp already synthesises `assistant-partial` events from
+    // the TUI frames on that path, so the flag has nothing to add there
+    // anyway — it is forwarded only under `--print-mode`.
+    printModeOnly: true,
+    description:
+      'Include partial assistant message chunks in stream-json output. ' +
+      'Forwarded upstream only under `--print-mode`; on the default PTY ' +
+      'path ocp emits `assistant-partial` events itself.',
     forward: { type: 'argv', flag: '--include-partial-messages' },
   },
 
@@ -244,8 +280,11 @@ export const OPTION_SPEC = [
   {
     name: 'effort',
     kind: 'enum',
-    choices: ['low', 'medium', 'high', 'max'],
-    description: 'Effort level the model should apply.',
+    choices: ['low', 'medium', 'high', 'xhigh', 'max'],
+    description:
+      'Effort level the model should apply (`low` | `medium` | `high` | ' +
+      '`xhigh` | `max`). `xhigh` sits between `high` and `max` and is the ' +
+      'upstream default for coding and agentic work.',
     forward: { type: 'argv', flag: '--effort' },
   },
   {
@@ -281,6 +320,14 @@ export const OPTION_SPEC = [
     description: 'API-side task budget in tokens. Shim-enforced.',
     forward: { type: 'shim' },
   },
+  {
+    name: 'autocompact',
+    kind: 'string',
+    description:
+      'Auto-compact window size: `auto`, or an explicit token budget ' +
+      'between 100k and 1M (e.g. `200000`, `500k`).',
+    forward: { type: 'argv', flag: '--autocompact' },
+  },
   {
     name: 'fallback-model',
     kind: 'string',
@@ -293,8 +340,10 @@ export const OPTION_SPEC = [
     name: 'permission-mode',
     kind: 'string',
     description:
-      'Permission mode (`default` | `plan` | `acceptEdits` | ' +
-      '`bypassPermissions` | `dontAsk` | `auto`).',
+      'Permission mode (`acceptEdits` | `auto` | `bypassPermissions` | ' +
+      '`manual` | `dontAsk` | `plan`). `manual` is the current name for ' +
+      "the interactive prompt-on-every-tool mode; upstream still accepts " +
+      'the older `default` spelling, so ocp keeps accepting it too.',
     forward: { type: 'argv', flag: '--permission-mode' },
   },
   {
@@ -305,6 +354,35 @@ export const OPTION_SPEC = [
       'Allow `--dangerously-skip-permissions` as a choice without enabling it.',
     forward: { type: 'argv', flag: '--allow-dangerously-skip-permissions' },
   },
+  {
+    name: 'permission-prompts',
+    kind: 'enum',
+    choices: ['host', 'none'],
+    description:
+      'Who answers permission prompts: `host` (the SDK host, or the tool ' +
+      'named by `--permission-prompt-tool`) or `none` (nobody — anything ' +
+      'that would prompt is denied automatically; the permission mode ' +
+      'still decides everything else). `none` suits PTY automation, which ' +
+      'has no way to answer a prompt, when denying is preferable to ' +
+      'bypassing checks outright.',
+    forward: { type: 'argv', flag: '--permission-prompts' },
+  },
+  {
+    name: 'restricted',
+    kind: 'boolean',
+    default: false,
+    description:
+      'Restricted mode: drop the built-in tools that run commands or code ' +
+      '(Bash, PowerShell, REPL, …) and WebFetch unless `--tools` names ' +
+      'them, ignore user/project/local settings files (managed settings ' +
+      'and `--settings` still apply), confine the file tools to the ' +
+      'working directories, and refuse `bypassPermissions`. Pair with ' +
+      '`--strict-mcp-config` to skip MCP servers too. Note that ocp does ' +
+      'not get its usual clean transcript in this mode — no session ' +
+      'JSONL is written for the run, so the reply is reconstructed from ' +
+      'the TUI frames and may carry leftover box-border chrome.',
+    forward: { type: 'argv', flag: '--restricted' },
+  },
   {
     name: 'tools',
     kind: 'string',
@@ -353,6 +431,29 @@ export const OPTION_SPEC = [
     description: 'Append to the system prompt from a file path.',
     forward: { type: 'argv', flag: '--append-system-prompt-file' },
   },
+  {
+    name: 'system-prompt-snapshot',
+    kind: 'enum',
+    choices: ['on', 'off'],
+    description:
+      'Record the system prompt once per conversation and reuse it ' +
+      'verbatim on every later request and resume (`on`, the upstream ' +
+      'default), or render it fresh every request (`off`, for iterating ' +
+      'on prompt text). With `on`, a later run passing different prompt ' +
+      'text is ignored until the conversation is compacted.',
+    forward: { type: 'argv', flag: '--system-prompt-snapshot' },
+  },
+  {
+    name: 'exclude-dynamic-system-prompt-sections',
+    kind: 'boolean',
+    default: false,
+    description:
+      'Move per-machine sections (cwd, env info, memory paths, git status) ' +
+      'out of the system prompt and into the first user message, so the ' +
+      'cached prompt prefix is identical across machines and users. Ignored ' +
+      'when `--system-prompt` replaces the default prompt.',
+    forward: { type: 'argv', flag: '--exclude-dynamic-system-prompt-sections' },
+  },
   {
     name: 'add-dir',
     kind: 'array',
@@ -387,6 +488,13 @@ export const OPTION_SPEC = [
     description: 'Load plugins from directory (repeatable).',
     forward: { type: 'argv', flag: '--plugin-dir' },
   },
+  {
+    name: 'plugin-url',
+    kind: 'array',
+    repeatable: true,
+    description: 'Fetch a plugin `.zip` from a URL for this session only (repeatable).',
+    forward: { type: 'argv', flag: '--plugin-url' },
+  },
   {
     name: 'disable-slash-commands',
     kind: 'boolean',
@@ -455,6 +563,38 @@ export const OPTION_SPEC = [
     description: 'Run Setup hooks with the `maintenance` trigger, then continue.',
     forward: { type: 'argv', flag: '--maintenance' },
   },
+  {
+    name: 'safe-mode',
+    kind: 'boolean',
+    default: false,
+    description:
+      'Start with all customizations disabled (CLAUDE.md, skills, plugins, ' +
+      'hooks, MCP servers, custom commands and agents, output styles, ' +
+      'workflows, themes, keybindings). Admin policy settings still apply. ' +
+      'Sets `CLAUDE_CODE_SAFE_MODE=1`. Useful for reproducing a failure ' +
+      'without local configuration in the way.',
+    forward: { type: 'argv', flag: '--safe-mode' },
+  },
+  {
+    name: 'ax-screen-reader',
+    kind: 'boolean',
+    default: false,
+    env: 'OCP_AX_SCREEN_READER',
+    description:
+      'Ask the upstream TUI for screen-reader friendly output: flat text, ' +
+      'no decorative borders, no animations. Because ocp reconstructs its ' +
+      'answer by scraping TUI frames, this markedly reduces the amount of ' +
+      'chrome the parsers have to strip. Opt-in — it changes the captured ' +
+      'frame shape, so it is never enabled by default.',
+    forward: { type: 'argv', flag: '--ax-screen-reader' },
+  },
+  {
+    name: 'brief',
+    kind: 'boolean',
+    default: false,
+    description: 'Enable the SendUserMessage tool for agent-to-user communication.',
+    forward: { type: 'argv', flag: '--brief' },
+  },
   {
     name: 'debug-file',
     kind: 'string',

package/src/options/validate.js

@@ -8,8 +8,14 @@
 // Rules are appended to `CROSS_RULES`; the runner returns the concatenated
 // list of human-readable errors.
 
+// Upstream (`claude --permission-mode`) advertises: acceptEdits, auto,
+// bypassPermissions, manual, dontAsk, plan. `manual` is the current name
+// for the prompt-on-every-tool mode that used to be spelled `default`;
+// upstream still accepts `default`, so we keep it here rather than
+// breaking callers that pass it.
 const PERMISSION_MODES = new Set([
-  'default', 'plan', 'acceptEdits', 'bypassPermissions', 'dontAsk', 'auto',
+  'acceptEdits', 'auto', 'bypassPermissions', 'manual', 'dontAsk', 'plan',
+  'default',
 ]);
 
 /** @type {Array<(options: Record<string, unknown>) => string | undefined>} */
@@ -85,6 +91,40 @@ export const CROSS_RULES = [
       return '`--fork-session` requires `--resume <id>` or `--continue`.';
     }
   },
+  // R11. forward-subagent-text => stream-json output. Upstream only emits
+  //      the extra assistant/user messages on the stream-json channel.
+  (o) => {
+    if (o['forward-subagent-text'] === true && o['output-format'] !== 'stream-json') {
+      return '`--forward-subagent-text` requires `--output-format=stream-json`.';
+    }
+  },
+  // R12. prompt-suggestions => stream-json output. The suggestion arrives
+  //      as its own `prompt_suggestion` event; the text and json adapters
+  //      have nowhere to put it.
+  (o) => {
+    if (o['prompt-suggestions'] === true && o['output-format'] !== 'stream-json') {
+      return '`--prompt-suggestions` requires `--output-format=stream-json`.';
+    }
+  },
+  // R13. autocompact takes `auto` or a token budget in the 100k–1M range.
+  //      Accepts a bare integer or a `k`/`m` suffix.
+  (o) => {
+    const v = o.autocompact;
+    if (v === undefined) return undefined;
+    if (typeof v !== 'string' || v === '') {
+      return '`--autocompact` must be `auto` or a token budget between 100k and 1M.';
+    }
+    if (v === 'auto') return undefined;
+    const m = /^(\d+(?:\.\d+)?)([km])?$/i.exec(v.trim());
+    if (!m) {
+      return `\`--autocompact\` must be \`auto\` or a token budget between 100k and 1M; got ${JSON.stringify(v)}.`;
+    }
+    const mult = m[2] ? { k: 1e3, m: 1e6 }[m[2].toLowerCase()] : 1;
+    const tokens = Number(m[1]) * mult;
+    if (!(tokens >= 100_000 && tokens <= 1_000_000)) {
+      return `\`--autocompact\` token budget must be between 100k and 1M; got ${JSON.stringify(v)}.`;
+    }
+  },
 ];
 
 /**