impel-cli 0.16.3 → 0.16.5

package/src/codexSetup.js

@@ -49,8 +49,17 @@ const START_MARK = `# >>> impel-cli managed block (model_providers.${PROVIDER_ID
 const END_MARK = `# <<< impel-cli managed block <<<`;
 
 const PROVIDER_LINE_RE = /^model_provider[ \t]*=[ \t]*"([^"]*)"[ \t]*$/m;
+const NETWORK_TABLE = "sandbox_workspace_write";
+const NETWORK_KEY = "network_access";
+const NETWORK_DOTTED_RE = /^(\s*)sandbox_workspace_write\.network_access\s*=.*$/u;
+const NETWORK_HEADER_RE = /^\s*\[sandbox_workspace_write\]\s*(?:#.*)?$/u;
+const NETWORK_KEY_RE = /^(\s*)network_access\s*=.*$/u;
+const SANDBOX_MODE_RE = /^(\s*)sandbox_mode\s*=.*$/u;
 
-function providerTablesBlock(gatewayUrl) {
+function providerTablesBlock(
+  gatewayUrl,
+  { includeNetworkAccess = false, includeSandboxMode = false } = {},
+) {
   const baseUrl = impelCodexBaseUrl(gatewayUrl);
   const auth = impelCliInvocation(["token"]);
   const mcp = impelCliInvocation(["mcp"]);
@@ -58,6 +67,8 @@ function providerTablesBlock(gatewayUrl) {
     START_MARK,
     "# Generated by `impel use gateway codex`. Safe to re-run; do not hand-edit",
     "# the lines between the markers above/below, they'll be overwritten.",
+    ...(includeSandboxMode ? ['sandbox_mode = "workspace-write"'] : []),
+    ...(includeNetworkAccess ? [`${NETWORK_TABLE}.${NETWORK_KEY} = true`, ""] : []),
     `[model_providers.${PROVIDER_ID}]`,
     `name = "Impel Gateway"`,
     `base_url = "${baseUrl}"`,
@@ -76,6 +87,123 @@ function providerTablesBlock(gatewayUrl) {
   ].join("\n");
 }
 
+function applyCodexSandboxMode(text, configPath = CODEX_CONFIG_PATH) {
+  const lines = String(text || "").replace(/\r\n/gu, "\n").split("\n");
+  const firstTable = lines.findIndex((line) => /^\s*\[/u.test(line));
+  const preambleEnd = firstTable === -1 ? lines.length : firstTable;
+  const indices = lines
+    .slice(0, preambleEnd)
+    .flatMap((line, index) => (SANDBOX_MODE_RE.test(line) ? [index] : []));
+  if (indices.length > 1) {
+    throw new Error(`${configPath} defines sandbox_mode more than once; resolve it before re-running.`);
+  }
+  if (indices.length === 0) {
+    return { text, prior: { kind: "absent" }, includeInBlock: true };
+  }
+  const index = indices[0];
+  const line = lines[index];
+  const indent = line.match(SANDBOX_MODE_RE)?.[1] || "";
+  lines[index] = `${indent}sandbox_mode = "workspace-write"`;
+  return {
+    text: lines.join("\n"),
+    prior: { kind: "root", line },
+    includeInBlock: false,
+  };
+}
+
+function restoreCodexSandboxMode(text, snapshot) {
+  if (!snapshot || snapshot.kind === "absent") return { text, changed: false };
+  const lines = String(text || "").replace(/\r\n/gu, "\n").split("\n");
+  const firstTable = lines.findIndex((line) => /^\s*\[/u.test(line));
+  const preambleEnd = firstTable === -1 ? lines.length : firstTable;
+  const indices = lines
+    .slice(0, preambleEnd)
+    .flatMap((line, index) => (SANDBOX_MODE_RE.test(line) ? [index] : []));
+  if (indices.length !== 1 || !/^\s*sandbox_mode\s*=\s*"workspace-write"\s*(?:#.*)?$/u.test(lines[indices[0]])) {
+    return { text, changed: false };
+  }
+  lines[indices[0]] = snapshot.line;
+  return { text: lines.join("\n"), changed: true };
+}
+
+function locateCodexNetworkAccess(text, configPath = CODEX_CONFIG_PATH) {
+  const lines = String(text || "").replace(/\r\n/gu, "\n").split("\n");
+  const firstTable = lines.findIndex((line) => /^\s*\[/u.test(line));
+  const preambleEnd = firstTable === -1 ? lines.length : firstTable;
+  const dotted = lines
+    .slice(0, preambleEnd)
+    .flatMap((line, index) => (NETWORK_DOTTED_RE.test(line) ? [index] : []));
+  const headers = lines.flatMap((line, index) => (NETWORK_HEADER_RE.test(line) ? [index] : []));
+  if (dotted.length > 1 || headers.length > 1 || (dotted.length && headers.length)) {
+    throw new Error(`${configPath} defines ${NETWORK_TABLE}.${NETWORK_KEY} more than once; resolve it before re-running.`);
+  }
+  if (dotted.length === 1) {
+    const index = dotted[0];
+    return { lines, kind: "dotted", index, line: lines[index] };
+  }
+  if (headers.length === 1) {
+    const header = headers[0];
+    const nextTableOffset = lines.slice(header + 1).findIndex((line) => /^\s*\[/u.test(line));
+    const end = nextTableOffset === -1 ? lines.length : header + 1 + nextTableOffset;
+    const keys = lines
+      .slice(header + 1, end)
+      .flatMap((line, index) => (NETWORK_KEY_RE.test(line) ? [header + 1 + index] : []));
+    if (keys.length > 1) {
+      throw new Error(`${configPath} defines ${NETWORK_KEY} more than once in [${NETWORK_TABLE}].`);
+    }
+    if (keys.length === 1) {
+      const index = keys[0];
+      return { lines, kind: "table", index, line: lines[index] };
+    }
+    return { lines, kind: "table-missing", header };
+  }
+  if (lines.slice(0, preambleEnd).some((line) => /^\s*sandbox_workspace_write\s*=/u.test(line))) {
+    throw new Error(`${configPath} defines ${NETWORK_TABLE} as an inline table; convert it to [${NETWORK_TABLE}] before re-running.`);
+  }
+  return { lines, kind: "absent" };
+}
+
+function applyCodexNetworkAccess(text, configPath = CODEX_CONFIG_PATH) {
+  const state = locateCodexNetworkAccess(text, configPath);
+  if (state.kind === "absent") {
+    return { text, prior: { kind: "absent" }, includeInBlock: true };
+  }
+  if (state.kind === "table-missing") {
+    state.lines.splice(state.header + 1, 0, `${NETWORK_KEY} = true`);
+    return {
+      text: state.lines.join("\n"),
+      prior: { kind: "table-missing" },
+      includeInBlock: false,
+    };
+  }
+  const indent = state.line.match(state.kind === "dotted" ? NETWORK_DOTTED_RE : NETWORK_KEY_RE)?.[1] || "";
+  state.lines[state.index] = state.kind === "dotted"
+    ? `${indent}${NETWORK_TABLE}.${NETWORK_KEY} = true`
+    : `${indent}${NETWORK_KEY} = true`;
+  return {
+    text: state.lines.join("\n"),
+    prior: { kind: state.kind, line: state.line },
+    includeInBlock: false,
+  };
+}
+
+function restoreCodexNetworkAccess(text, snapshot, configPath = CODEX_CONFIG_PATH) {
+  if (!snapshot || snapshot.kind === "absent") return { text, changed: false };
+  const state = locateCodexNetworkAccess(text, configPath);
+  if (!["dotted", "table"].includes(state.kind) || !/=\s*true\s*(?:#.*)?$/u.test(state.line)) {
+    return { text, changed: false };
+  }
+  if (snapshot.kind === "table-missing" && state.kind === "table") {
+    state.lines.splice(state.index, 1);
+    return { text: state.lines.join("\n"), changed: true };
+  }
+  if (snapshot.kind !== state.kind || typeof snapshot.line !== "string") {
+    return { text, changed: false };
+  }
+  state.lines[state.index] = snapshot.line;
+  return { text: state.lines.join("\n"), changed: true };
+}
+
 function readConfig() {
   const exists = fs.existsSync(CODEX_CONFIG_PATH);
   const text = exists ? fs.readFileSync(CODEX_CONFIG_PATH, "utf8") : "";
@@ -155,7 +283,10 @@ export function applyCodexGateway(gatewayUrl) {
     );
   }
 
-  const { preamble, rest } = splitPreamble(withoutOurBlock);
+  const sandboxMode = applyCodexSandboxMode(withoutOurBlock);
+  const networkAccess = applyCodexNetworkAccess(sandboxMode.text);
+
+  const { preamble, rest } = splitPreamble(networkAccess.text);
   const priorProviderValue = preamble.match(PROVIDER_LINE_RE)?.[1] ?? null;
   const newProviderLine = `model_provider = "${PROVIDER_ID}"`;
 
@@ -167,7 +298,10 @@ export function applyCodexGateway(gatewayUrl) {
     newPreamble = trimmed ? `${trimmed}\n${newProviderLine}\n` : `${newProviderLine}\n`;
   }
 
-  const block = providerTablesBlock(gatewayUrl);
+  const block = providerTablesBlock(gatewayUrl, {
+    includeNetworkAccess: networkAccess.includeInBlock,
+    includeSandboxMode: sandboxMode.includeInBlock,
+  });
   const restTrimmed = rest.trim();
   const newText = `${newPreamble.trimEnd()}\n\n${block}\n` + (restTrimmed ? `\n${restTrimmed}\n` : "");
 
@@ -177,6 +311,8 @@ export function applyCodexGateway(gatewayUrl) {
     path: CODEX_CONFIG_PATH,
     baseUrl: impelCodexBaseUrl(gatewayUrl),
     priorProviderValue,
+    priorNetworkAccess: networkAccess.prior,
+    priorSandboxMode: sandboxMode.prior,
   };
 }
 
@@ -196,6 +332,11 @@ export function revertCodexGateway(backup = {}) {
   const removedBlock = original.includes(START_MARK);
   let text = stripManagedBlock(original);
 
+  const networkAccess = restoreCodexNetworkAccess(text, backup.network_access);
+  text = networkAccess.text;
+  const sandboxMode = restoreCodexSandboxMode(text, backup.sandbox_mode);
+  text = sandboxMode.text;
+
   let resetProvider = false;
   let restoredProvider = null;
   if (currentProviderValue(text) === PROVIDER_ID) {
@@ -220,5 +361,7 @@ export function revertCodexGateway(backup = {}) {
     removedBlock,
     resetProvider,
     restoredProvider,
+    restoredNetworkAccess: networkAccess.changed,
+    restoredSandboxMode: sandboxMode.changed,
   };
 }

package/src/commands/sessions.js

@@ -0,0 +1,114 @@
+import { spawn } from "node:child_process";
+
+import { parseFlags } from "../args.js";
+import { collectSessionHook, flushCollectedSession, readHookInput, sessionOutboxStatus } from "../sessionCollector.js";
+import { loadConfig, redactSecretText } from "../config.js";
+import { impelCliInvocation } from "../selfInvocation.js";
+
+const SPEC = {
+  provider: { type: "string" },
+  surface: { type: "string" },
+  tenant: { type: "string" },
+  session: { type: "string" },
+  "impel-managed-session-hook-v1": { type: "boolean" },
+};
+
+function startDetachedFlush({ provider, tenant, session }) {
+  const invocation = impelCliInvocation([
+    "sessions",
+    "flush",
+    "--provider",
+    provider,
+    "--tenant",
+    tenant,
+    "--session",
+    session,
+    "--impel-managed-session-hook-v1",
+  ]);
+  const child = spawn(invocation.command, invocation.args, {
+    detached: true,
+    stdio: "ignore",
+    env: { ...process.env, IMPEL_SESSIONS_FLUSH_CHILD: "1" },
+    windowsHide: true,
+  });
+  child.once("error", () => {});
+  child.unref();
+}
+
+export async function cmdSessions(argv) {
+  const [action, ...rest] = argv;
+  if (action === "hook") {
+    try {
+      const { flags, positionals } = parseFlags(rest, SPEC);
+      if (positionals.length > 0) throw new Error("unexpected positional arguments");
+      const input = await readHookInput();
+      let config = null;
+      try {
+        config = loadConfig();
+      } catch {
+        // Capture remains available even while the user's config needs repair.
+      }
+      await collectSessionHook({
+        provider: flags.provider,
+        surface: flags.surface,
+        tenantId: flags.tenant,
+        input,
+        config,
+        flush: false,
+      });
+      if (config && (config.tenantId === flags.tenant || process.env.IMPEL_SESSIONS_DEV_ORG_ID)) {
+        startDetachedFlush({
+          provider: flags.provider,
+          tenant: flags.tenant,
+          session: String(input.session_id || ""),
+        });
+      }
+    } catch (error) {
+      // Session persistence is observational. A collector outage must never
+      // block a model turn or change a provider hook's decision semantics.
+      if (process.env.IMPEL_SESSIONS_DEBUG === "1") {
+        console.error(`impel sessions hook: ${redactSecretText(error?.message || error)}`);
+      }
+    }
+    return;
+  }
+  const { flags, positionals } = parseFlags(rest, SPEC);
+  if (positionals.length > 0) {
+    console.error("impel sessions: unexpected positional arguments");
+    process.exitCode = 1;
+    return;
+  }
+  const config = loadConfig();
+  if (action === "flush") {
+    if (!flags.provider || !flags.session || !flags.tenant) return;
+    if (!["claude_code", "codex"].includes(flags.provider)) return;
+    if (!config || flags.tenant !== config.tenantId && !process.env.IMPEL_SESSIONS_DEV_ORG_ID) return;
+    const deadline = Date.now() + 90_000;
+    while (Date.now() < deadline) {
+      const result = await flushCollectedSession({
+        tenantId: flags.tenant,
+        provider: flags.provider,
+        sessionKey: flags.session,
+        config,
+      });
+      if (result.pending === 0) break;
+      await new Promise((resolve) => setTimeout(resolve, result.error || result.busy ? 1000 : 250));
+    }
+    return;
+  }
+  if (action === "status") {
+    if (!flags.provider || !flags.session || !flags.tenant) {
+      console.error("impel sessions status requires --provider, --session, and --tenant");
+      process.exitCode = 1;
+      return;
+    }
+    console.log(JSON.stringify(sessionOutboxStatus({
+      tenantId: flags.tenant,
+      provider: flags.provider,
+      sessionKey: flags.session,
+    }), null, 2));
+    return;
+  }
+  console.error("impel sessions: use `hook` (managed internally) or `status`");
+  process.exitCode = 1;
+}

package/src/commands/use.js

@@ -78,6 +78,11 @@ async function useGateway({ target, app }) {
     }
     if (!Object.hasOwn(backup, "sandbox")) {
       backup.sandbox = result.priorSandbox;
+    } else if (
+      !Object.hasOwn(backup.sandbox, "permissions")
+      && Object.hasOwn(result.priorSandbox, "permissions")
+    ) {
+      backup.sandbox.permissions = result.priorSandbox.permissions;
     }
     console.log(`Claude Code -> GATEWAY  (${result.path})`);
     console.log(`  apiKeyHelper = "${result.apiKeyHelper}"`);
@@ -99,12 +104,19 @@ async function useGateway({ target, app }) {
     if (result.priorProviderValue !== PROVIDER_ID) {
       backup.model_provider = result.priorProviderValue ?? null;
     }
+    if (!Object.hasOwn(backup, "network_access")) {
+      backup.network_access = result.priorNetworkAccess;
+    }
+    if (!Object.hasOwn(backup, "sandbox_mode")) {
+      backup.sandbox_mode = result.priorSandboxMode;
+    }
 
     console.log(`Codex ${app ? "app/IDE" : "CLI"} -> GATEWAY  (${result.path})`);
     console.log(`  model_provider = "${PROVIDER_ID}"`);
     console.log(`  [model_providers.${PROVIDER_ID}] base_url = "${result.baseUrl}"`);
     console.log(`  [model_providers.${PROVIDER_ID}.auth] = direct Impel CLI invocation`);
     console.log(`  [mcp_servers.${PROVIDER_ID}] = direct Impel CLI invocation`);
+    console.log(`  sandbox workspace-write network = unrestricted`);
   }
 
   saveConfig(config);
@@ -194,6 +206,8 @@ function useAccount({ target, app }) {
             : `  removed model_provider line (Codex falls back to its default)`
         );
       }
+      if (result.restoredNetworkAccess) console.log(`  restored prior Codex sandbox network setting`);
+      if (result.restoredSandboxMode) console.log(`  restored prior Codex sandbox mode`);
     }
     if (config?.backups) delete config.backups.codex;
   }

package/src/config.js

@@ -89,11 +89,16 @@ const PAT_RE = /impel_pat_[A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]+)?/gu;
 const ANSI_ESCAPE_RE = /\u001B(?:\][^\u0007\u001B]*(?:\u0007|\u001B\\)|\[[0-?]*[ -/]*[@-~]|[@-_])/gu;
 const TERMINAL_CONTROL_RE = /[\u0000-\u001F\u007F-\u009F]/gu;
 
-/** Remove credentials and terminal control sequences from untrusted text. */
-export function redactSecretText(value) {
+/** Redact Impel bearer credentials without changing JSON/NDJSON whitespace. */
+export function redactCredentialText(value) {
   return String(value ?? "")
     .replace(TENANT_CREDENTIAL_RE, "[REDACTED IMPEL CREDENTIAL]")
-    .replace(PAT_RE, "[REDACTED IMPEL CREDENTIAL]")
+    .replace(PAT_RE, "[REDACTED IMPEL CREDENTIAL]");
+}
+
+/** Remove credentials and terminal control sequences from untrusted text. */
+export function redactSecretText(value) {
+  return redactCredentialText(value)
     .replace(ANSI_ESCAPE_RE, "")
     .replace(TERMINAL_CONTROL_RE, " ");
 }

package/src/gateway/index.js

@@ -6,6 +6,7 @@ import readline from "node:readline";
 
 import { nativeCommandInvocation } from "../nativeProcess.js";
 import { applyImpelClaudeSandbox } from "../claudeSandbox.js";
+import { enableManagedCodexNetworkAccess } from "../codexSecurity.js";
 
 const SAFE_ID = /^[a-z][a-z0-9-]{2,31}$/u;
 const SAFE_NAMESPACE = /^[a-z][a-z0-9_-]{1,31}$/u;
@@ -355,7 +356,7 @@ export function createGatewayCli(options) {
     const withoutProvider = outside.replace(/^\s*model_provider\s*=.*$/mu, "").trim();
     const next = [`model_provider = ${JSON.stringify(brand.cli.providerId)}`, codexManagedBlock(gatewayUrl), withoutProvider]
       .filter(Boolean).join("\n\n").concat("\n");
-    writePrivateFile(filePath, next);
+    writePrivateFile(filePath, enableManagedCodexNetworkAccess(next, filePath));
     return { codexHome, filePath };
   }