impel-cli 0.20.1 → 0.20.2-beta.0

package/src/apps.js

@@ -107,8 +107,8 @@ export const PINNED_VENDOR_APPS = Object.freeze({
       // The Microsoft Store manifest identifies this exact reviewed build.
       // Keep one Windows package version so the manifest contract and local
       // AppX validation cannot silently drift apart again.
-      packageVersion: "26.727.6591.0",
-      codexVersion: "0.146.0-alpha.9.2",
+      packageVersion: "26.730.8199.0",
+      codexVersion: "0.147.0-alpha.1.2",
       publisherId: "2p2nqsd0c76g0",
       executable: "app\\ChatGPT.exe",
       updateManifestUrl: "https://persistent.oaistatic.com/codex-app-prod/windows-store-update.json",
@@ -274,7 +274,9 @@ export function managedAppIdentity(target, tenantId = null, tenantName = null) {
 // unsupported-selection "Reset to default" treatment.
 // 27: register the separate tenant-bound Tasks MCP server in managed Claude
 // and ChatGPT/Codex profiles without changing the specialist MCP server.
-export const CURRENT_CONFIG_VERSION = 27;
+// 28: bind generated native-agent profiles to the durable local composite MCP
+// transport and remove model-controlled upstream start/read polling.
+export const CURRENT_CONFIG_VERSION = 28;
 
 // Identifies the bundle-BUILDING logic — the asar patches, plist rewrites,
 // helper rebranding, and signing. A vendored bundle is rebuilt only when this

package/src/commands/mcp.js

@@ -8,6 +8,15 @@ import {
   resolveDefaultGateway,
 } from "../config.js";
 import { parseFlags } from "../args.js";
+import {
+  NATIVE_AGENT_RECOVER_TOOL,
+  NATIVE_AGENT_RESUME_TOOL,
+  NATIVE_AGENT_RUN_TOOL,
+  NativeAgentCompositeTransport,
+  nativeAgentCompositeTools,
+  nativeAgentToolCallResult,
+} from "../nativeAgentTransport.js";
+import { IMPEL_NATIVE_AGENT_MCP_TARGET } from "../selfInvocation.js";
 import { ensureTenantSelection, normalizeTenantId, tenantCredential } from "../tenants.js";
 
 const TASKS_TARGET = "tasks";
@@ -168,16 +177,142 @@ function tasksJsonRpcHttpError(id, contentType, body, httpStatus) {
   return JSON.stringify({ jsonrpc: "2.0", id: id ?? null, error });
 }
 
+function nativeRpcResult(id, result) {
+  return JSON.stringify({ jsonrpc: "2.0", id, result });
+}
+
+function nativeProgressToken(message) {
+  const token = message?.params?._meta?.progressToken;
+  return typeof token === "string" || (typeof token === "number" && Number.isFinite(token))
+    ? token
+    : null;
+}
+
+/** Run the isolated local composite MCP server without changing proxy mode. */
+export function runNativeAgentMcpServer({
+  transport,
+  input = process.stdin,
+  output = process.stdout,
+  recoveryOnly = false,
+}) {
+  const lines = readline.createInterface({ input, crlfDelay: Infinity });
+  const active = new Map();
+  const pending = new Set();
+  let progress = 0;
+  const write = (value) => output.write(`${value}\n`);
+
+  function schedule(message) {
+    const request = tasksJsonRpcRequestId(message);
+    if (!request.valid) {
+      write(rpcError(request.id, "Invalid JSON-RPC request."));
+      return;
+    }
+    if (message.method === "notifications/initialized") return;
+    if (message.method === "notifications/cancelled") {
+      active.get(message.params?.requestId)?.abort();
+      return;
+    }
+    if (!Object.hasOwn(message, "id")) return;
+
+    const controller = new AbortController();
+    active.set(message.id, controller);
+    const task = (async () => {
+      try {
+        if (message.method === "initialize") {
+          write(nativeRpcResult(message.id, {
+            protocolVersion: "2025-06-18",
+            capabilities: { tools: {} },
+            serverInfo: { name: "impel-native-agent", version: "1.0.0" },
+          }));
+          return;
+        }
+        if (message.method === "ping") {
+          write(nativeRpcResult(message.id, {}));
+          return;
+        }
+        if (message.method === "tools/list") {
+          write(nativeRpcResult(message.id, { tools: nativeAgentCompositeTools({ recoveryOnly }) }));
+          return;
+        }
+        if (message.method !== "tools/call") {
+          throw new Error("unsupported native-agent MCP method");
+        }
+        const name = message.params?.name;
+        const args = message.params?.arguments ?? {};
+        const progressToken = nativeProgressToken(message);
+        const onProgress = progressToken === null ? undefined : ({ status }) => {
+          progress += 1;
+          write(JSON.stringify({
+            jsonrpc: "2.0",
+            method: "notifications/progress",
+            params: { progressToken, progress, message: `native-agent run ${status}` },
+          }));
+        };
+        let value;
+        if (name === NATIVE_AGENT_RUN_TOOL) {
+          if (recoveryOnly) throw new Error("retired native-agent bindings cannot start new runs");
+          value = await transport.run(args, { signal: controller.signal, onProgress });
+        } else if (name === NATIVE_AGENT_RESUME_TOOL) {
+          value = await transport.resume(args, { signal: controller.signal, onProgress });
+        } else if (name === NATIVE_AGENT_RECOVER_TOOL) {
+          value = transport.recover(args);
+        } else {
+          throw new Error("unsupported native-agent MCP tool");
+        }
+        write(nativeRpcResult(message.id, nativeAgentToolCallResult(value)));
+      } catch (error) {
+        const cancelled = error?.name === "AbortError";
+        write(JSON.stringify({
+          jsonrpc: "2.0",
+          id: message.id,
+          error: {
+            code: cancelled ? -32800 : -32000,
+            message: cancelled
+              ? "Native-agent attachment cancelled; resume it with the same handle."
+              : redactSecretText(error?.message || error),
+          },
+        }));
+      } finally {
+        active.delete(message.id);
+      }
+    })();
+    pending.add(task);
+    task.finally(() => pending.delete(task));
+  }
+
+  lines.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    try {
+      schedule(JSON.parse(trimmed));
+    } catch {
+      write(rpcError(null, "Invalid JSON-RPC request."));
+    }
+  });
+  return new Promise((resolve) => {
+    lines.on("close", async () => {
+      for (const controller of active.values()) controller.abort();
+      await Promise.allSettled([...pending]);
+      resolve();
+    });
+  });
+}
+
 export async function cmdMcp(argv = []) {
   const { flags, positionals } = parseFlags(argv, {
     target: { type: "string" },
     tenant: { type: "string" },
+    "agent-id": { type: "string" },
+    "scope-param": { type: "string" },
+    "policy-fingerprint": { type: "string" },
+    "recovery-only": { type: "boolean" },
   });
   const targetSpecified = Object.hasOwn(flags, "target");
-  if (targetSpecified && flags.target !== TASKS_TARGET) {
-    throw new Error("unsupported MCP target; expected `--target tasks`");
+  if (targetSpecified && ![TASKS_TARGET, IMPEL_NATIVE_AGENT_MCP_TARGET].includes(flags.target)) {
+    throw new Error("unsupported MCP target; expected `--target tasks` or `--target native-agent`");
   }
   const tasksTarget = flags.target === TASKS_TARGET;
+  const nativeAgentTarget = flags.target === IMPEL_NATIVE_AGENT_MCP_TARGET;
   if (tasksTarget) {
     const unsupportedFlags = Object.keys(flags).filter((name) => !["target", "tenant"].includes(name));
     if (unsupportedFlags.length > 0 || positionals.length > 0) {
@@ -187,6 +322,23 @@ export async function cmdMcp(argv = []) {
       throw new Error("Tasks MCP requires a fixed `--tenant <tenant>` argument");
     }
   }
+  if (nativeAgentTarget) {
+    const expectedFlags = ["target", "tenant", "agent-id", "scope-param", "policy-fingerprint", "recovery-only"];
+    const unsupportedFlags = Object.keys(flags).filter((name) => !expectedFlags.includes(name));
+    if (unsupportedFlags.length > 0 || positionals.length > 0) {
+      throw new Error("unsupported native-agent MCP arguments");
+    }
+    for (const flag of ["tenant", "agent-id", "scope-param", "policy-fingerprint"]) {
+      if (typeof flags[flag] !== "string" || !flags[flag].trim()) {
+        throw new Error(`native-agent MCP requires a fixed --${flag} argument`);
+      }
+    }
+  } else if (!tasksTarget && (Object.hasOwn(flags, "agent-id")
+    || Object.hasOwn(flags, "scope-param")
+    || Object.hasOwn(flags, "policy-fingerprint")
+    || Object.hasOwn(flags, "recovery-only"))) {
+    throw new Error("native-agent binding flags require `--target native-agent`");
+  }
   const config = loadConfig();
   if (!config?.pat) {
     throw new Error("not authenticated; run `impel setup` (or `impel auth`) first");
@@ -196,6 +348,19 @@ export async function cmdMcp(argv = []) {
     : (await ensureTenantSelection(config)).tenantId;
   const gatewayUrl = config.gatewayUrl || resolveDefaultGateway();
   const credential = tasksTarget ? null : tenantCredential(config.pat, tenantId);
+  if (nativeAgentTarget) {
+    return runNativeAgentMcpServer({
+      transport: new NativeAgentCompositeTransport({
+        tenantId,
+        agentId: flags["agent-id"],
+        scopeParam: flags["scope-param"],
+        policyFingerprint: flags["policy-fingerprint"],
+        gatewayUrl,
+        credential,
+      }),
+      recoveryOnly: flags["recovery-only"] === true,
+    });
+  }
   const endpoint = tasksTarget ? null : `${gatewayUrl}/mcp`;
   const input = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
   let sessionId;