imprint-mcp 0.7.0 → 0.7.2

package/src/cli.ts

@@ -6,7 +6,7 @@ import { basename, dirname, resolve } from 'node:path';
 import { parseArgs } from 'node:util';
 import { IS_COMPILED_BINARY } from './imprint/is-compiled.ts';
 import type { ProviderName } from './imprint/llm.ts';
-import { isDebug } from './imprint/log.ts';
+import { createLog, isDebug } from './imprint/log.ts';
 import type { FreshTeachTerminalResult } from './imprint/master-teach-controller.ts';
 import { shutdownTracing, traced } from './imprint/tracing.ts';
 import { VERSION } from './imprint/version.ts';
@@ -142,7 +142,7 @@ export const VERB_HELP: Record<string, VerbHelp> = {
       {
         name: '--from-session <path>',
         description:
-          'Use one exact recording. Repeat the flag to explicitly combine selected recordings. Without it, the newest raw recording is used.',
+          'Use one exact recording. Repeat the flag to explicitly combine selected recordings. Existing login references use stored credentials. Without it, the newest raw recording is used.',
       },
       {
         name: '--from-candidates <run-id>',
@@ -157,7 +157,8 @@ export const VERB_HELP: Record<string, VerbHelp> = {
       { name: '--persist-profile', description: 'Reuse a stable Chrome profile for this site.' },
       {
         name: '--no-interactive',
-        description: 'Run without prompts. Every tool in the master plan is still built.',
+        description:
+          'Disable terminal questions, including MFA/OTP input. Missing user input is reported as unavailable; the complete tool scope remains planned.',
       },
       {
         name: '--agent codex',
@@ -172,7 +173,7 @@ export const VERB_HELP: Record<string, VerbHelp> = {
       {
         name: '--model <name>',
         description:
-          'Override the teaching-agent model (e.g. claude-sonnet-4-6). Otherwise the provider default is used.',
+          'Override the teaching-agent model (e.g. claude-sonnet-4-6). Codex defaults to gpt-6.1-sol; otherwise the provider default is used.',
       },
       {
         name: '--timeout <duration>',
@@ -458,7 +459,7 @@ export const VERB_HELP: Record<string, VerbHelp> = {
   },
   audit: {
     summary:
-      "Drive a headless agent against a site's MCP tools, exercise each one, and compute a deterministic accuracy score. Verdicts come from the agent; the score is computed by imprint.",
+      "Drive a headless agent against a site's MCP tools, exercise each one, and compute a deterministic accuracy score. Verdicts come from the agent; the score is computed by imprint. Browser tools inherit explicitly configured Chrome, headed-mode, proxy, display, and session-cache settings.",
     usage: [
       'imprint audit <site> [--strict] [--min-score <n>] [--out <path>] [--model <name>] [--timeout <duration>] [--json]',
     ],
@@ -851,22 +852,29 @@ async function main(argv: string[]): Promise<number> {
       // piped, backgrounded) get visibility instead of silence.
       let lastActivity = '';
       const compileStart = Date.now();
+      const compileLog = createLog('compile');
       const onDeadlineReached = process.stdin.isTTY
         ? async (): Promise<number | null> => {
-            const { createInterface } = await import('node:readline');
+            const { requestAgentInteraction } = await import('./imprint/user-interaction.ts');
             const elapsed = Math.round((Date.now() - compileStart) / 60000);
-            const rl = createInterface({ input: process.stdin, output: process.stderr });
-            const answer = await new Promise<string>((resolve) => {
-              rl.question(
-                `[imprint compile] Timeout reached after ${elapsed} minutes. Give it 10 more minutes? [Y/n] `,
-                resolve,
-              );
+            const answer = await requestAgentInteraction({
+              action: 'prompt_user',
+              prompt: {
+                message: `Timeout reached after ${elapsed} minutes. Give the compiler 10 more minutes?`,
+                options: ['Continue for 10 minutes', 'Stop'],
+                sensitive: false,
+              },
             });
-            rl.close();
-            return answer.trim().toLowerCase().startsWith('n') ? null : 10 * 60 * 1000;
+            return answer.status === 'answered' &&
+              'value' in answer &&
+              answer.value === 'Continue for 10 minutes'
+              ? 10 * 60 * 1000
+              : null;
           }
         : undefined;
+      const { terminalUserPrompt } = await import('./imprint/terminal-user-prompt.ts');
       const result = await generate({
+        onPrompt: terminalUserPrompt,
         sessionPath,
         outPath: values.out,
         maxDurationMs,
@@ -878,9 +886,7 @@ async function main(argv: string[]): Promise<number> {
           if (activity === lastActivity) return;
           lastActivity = activity;
           const retry = p.verificationCycle > 1 ? ` (retry ${p.verificationCycle - 1})` : '';
-          process.stderr.write(
-            `[imprint compile] ${formatElapsed(p.elapsedMs)} — ${activity}${retry}\n`,
-          );
+          compileLog(`${formatElapsed(p.elapsedMs)} — ${activity}${retry}`);
         },
       });
       console.log('');
@@ -1564,6 +1570,7 @@ async function main(argv: string[]): Promise<number> {
 
       try {
         const { teach } = await import('./imprint/teach.ts');
+        const { terminalUserPrompt } = await import('./imprint/terminal-user-prompt.ts');
         const result = await traced(
           'cli.teach',
           'AGENT',
@@ -1591,13 +1598,14 @@ async function main(argv: string[]): Promise<number> {
               persistProfile: values['persist-profile'],
               signal: ctrl.signal,
               noInteractive: values['no-interactive'],
+              onPrompt: values['no-interactive'] ? undefined : terminalUserPrompt,
               provider: values.provider as ProviderName | undefined,
               model: values.model,
               maxDurationMs: teachTimeoutMs,
               unbounded: values.unbounded,
               keepTest: values['keep-test'] || process.env.IMPRINT_KEEP_TEST === '1',
               agent: values.agent === 'codex' ? 'codex' : undefined,
-              onProgress: (message) => console.error(`[imprint teach] ${message}`),
+              onProgress: createLog('teach'),
             }),
         );
         const summary = formatFreshTeachSummary(result);

package/src/imprint/agent-tool.ts

@@ -0,0 +1,15 @@
+/** Provider-neutral execution tool contract. */
+export interface AgentTool {
+  name: string;
+  description: string;
+  input_schema: {
+    type: 'object';
+    properties?: Record<string, unknown>;
+    required?: string[];
+    [k: string]: unknown;
+  };
+  handler: (
+    input: unknown,
+    request?: { signal?: AbortSignal },
+  ) => Promise<{ result: string; isError?: boolean }>;
+}

package/src/imprint/agent.ts

@@ -20,17 +20,8 @@ import {
 } from './provider-retry.ts';
 import { setSpanAttributes, traceToolIoEnabled, traced } from './tracing.ts';
 
-export interface AgentTool {
-  name: string;
-  description: string;
-  input_schema: {
-    type: 'object';
-    properties?: Record<string, unknown>;
-    required?: string[];
-    [k: string]: unknown;
-  };
-  handler: (input: unknown) => Promise<{ result: string; isError?: boolean }>;
-}
+import type { AgentTool } from './agent-tool.ts';
+export type { AgentTool } from './agent-tool.ts';
 
 export interface AgentProgress {
   /** 1-based turn number (turn 1 is the first LLM call). */

package/src/imprint/audit.ts

@@ -28,6 +28,7 @@ import { imprintHomeDir } from './paths.ts';
 import { type TeachState, loadTeachState } from './teach-state.ts';
 import { type ResolvedTool, discoverTools } from './tool-loader.ts';
 import { recordLlmUsageSpan, setSpanAttributes, totalPromptTokens, traced } from './tracing.ts';
+import { authActionOutcomes } from './types.ts';
 
 const log = createLog('audit');
 
@@ -214,7 +215,11 @@ export function partitionAuditTools(tools: readonly ResolvedTool[]): AuditToolPa
       continue;
     }
     const pauses = auth
-      ? Object.entries(auth.actions).filter(([, action]) => action.outcome.type === 'pause')
+      ? Object.entries(auth.actions).flatMap(([name, action]) =>
+          authActionOutcomes(action).flatMap((outcome) =>
+            outcome.type === 'pause' ? [`${name}: ${outcome.message}`] : [],
+          ),
+        )
       : [];
     if (pauses.length === 0) {
       eligible.push(tool);
@@ -223,11 +228,7 @@ export function partitionAuditTools(tools: readonly ResolvedTool[]): AuditToolPa
     }
 
     const receipt = readAuthVerificationReceiptStatus(tool.dir, tool.workflow);
-    const pauseSummary = pauses
-      .map(([name, action]) =>
-        action.outcome.type === 'pause' ? `${name}: ${action.outcome.message}` : name,
-      )
-      .join('; ');
+    const pauseSummary = pauses.join('; ');
     skippedInteractiveAuth.push({
       name: tool.workflow.toolName,
       reason: `requires human continuation (${pauseSummary})`,
@@ -549,8 +550,23 @@ interface RunAuditOptions {
   json?: boolean;
 }
 
-export function buildAuditMcpEnvironment(assetRoot = imprintHomeDir()): Record<string, string> {
+export function buildAuditMcpEnvironment(
+  assetRoot = imprintHomeDir(),
+  parentEnv: NodeJS.ProcessEnv = process.env,
+): Record<string, string> {
+  const browserEnv: Record<string, string> = {};
+  for (const name of [
+    'CHROMIUM_PATH',
+    'IMPRINT_CDP_HEADED',
+    'IMPRINT_JAR_MAX_AGE_SECONDS',
+    'IMPRINT_PROXY',
+    'DISPLAY',
+  ]) {
+    const value = parentEnv[name];
+    if (value !== undefined) browserEnv[name] = value;
+  }
   return {
+    ...browserEnv,
     // Codex MCP server `env` entries are an explicit environment, so relying on
     // the audit driver's inherited IMPRINT_HOME can make an isolated audit
     // silently fall back to ~/.imprint and expose stale tools.
@@ -560,6 +576,17 @@ export function buildAuditMcpEnvironment(assetRoot = imprintHomeDir()): Record<s
   };
 }
 
+/** Keep Codex's explicit MCP environment identical to Claude's JSON config. */
+export function buildAuditCodexMcpEnvArgs(
+  serverName: string,
+  env: Record<string, string>,
+): string[] {
+  return Object.entries(env).flatMap(([name, value]) => [
+    '-c',
+    `mcp_servers.${serverName}.env.${name}=${JSON.stringify(value)}`,
+  ]);
+}
+
 export function buildAuditMcpCommandArgs(site: string, toolNames: readonly string[]): string[] {
   return ['run', CLI_PATH, 'mcp-server', site, '--include-tools', toolNames.join(',')];
 }
@@ -1109,12 +1136,7 @@ ${buildAuditInitialPrompt(opts, unverifiedNote)}`;
     `mcp_servers.${serverName}.default_tools_approval_mode=${JSON.stringify('approve')}`,
     '-c',
     `mcp_servers.${serverName}.tool_timeout_sec=300`,
-    '-c',
-    `mcp_servers.${serverName}.env.IMPRINT_HOME=${JSON.stringify(mcpEnv.IMPRINT_HOME)}`,
-    '-c',
-    `mcp_servers.${serverName}.env.IMPRINT_AUDIT_PACING_MS=${JSON.stringify(mcpEnv.IMPRINT_AUDIT_PACING_MS)}`,
-    '-c',
-    `mcp_servers.${serverName}.env.IMPRINT_AUDIT_TOOL_DEADLINE_MS=${JSON.stringify(mcpEnv.IMPRINT_AUDIT_TOOL_DEADLINE_MS)}`,
+    ...buildAuditCodexMcpEnvArgs(serverName, mcpEnv),
     '-c',
     'shell_environment_policy.inherit=all',
     '-',

package/src/imprint/auth-browser-discovery.ts

@@ -0,0 +1,276 @@
+import { randomUUID } from 'node:crypto';
+import type CDP from 'chrome-remote-interface';
+import { z } from 'zod';
+import type { CapturedRequest } from './types.ts';
+
+export const AUTH_DISCOVERY_POOL_KEY = 'auth-browser-discovery';
+
+/** Browser mechanics only; the auth agent chooses the page, controls and factor. */
+export const AuthBrowserActionSchema = z.discriminatedUnion('action', [
+  z.object({ action: z.literal('inspect') }),
+  z.object({ action: z.literal('navigate'), url: z.string().url() }),
+  z.object({ action: z.literal('click'), selector: z.string().min(1) }),
+  z.object({ action: z.literal('fill'), selector: z.string().min(1), value: z.string() }),
+  z.object({ action: z.literal('select'), selector: z.string().min(1), value: z.string() }),
+  z.object({ action: z.literal('press'), key: z.string().min(1) }),
+  z.object({ action: z.literal('wait'), milliseconds: z.number().int().min(0).max(30_000) }),
+]);
+export type AuthBrowserAction = z.infer<typeof AuthBrowserActionSchema>;
+
+export interface AuthBrowserObservation {
+  sourceId: string;
+  page: {
+    url: string;
+    title: string;
+    bodyText: string;
+    controls: Array<{
+      selector: string;
+      tag: string;
+      type: string;
+      name: string;
+      text: string;
+      disabled: boolean;
+    }>;
+    controlsTruncated: boolean;
+  };
+  requests: CapturedRequest[];
+  captureErrors: Array<{ seq: number; message: string }>;
+}
+
+type Client = CDP.Client;
+
+/** Kept attached between checkpoints, including while the human handles an OTP.
+ * Request identity is allocated on send, never on response completion. */
+export class AuthBrowserDiscovery {
+  private readonly sourceId = randomUUID();
+  private readonly started = Date.now();
+  private sequence = 0;
+  private readonly inflight = new Map<string, CapturedRequest>();
+  private readonly changed = new Map<number, CapturedRequest>();
+  private readonly bodyReads = new Set<Promise<void>>();
+  private errors: AuthBrowserObservation['captureErrors'] = [];
+  private closed = false;
+
+  constructor(
+    private readonly client: Client,
+    private readonly timeoutMs: number,
+  ) {
+    client.Network.requestWillBeSent((event) => {
+      if (this.closed) return;
+      const previous = this.inflight.get(event.requestId);
+      if (previous && event.redirectResponse) {
+        previous.response = {
+          status: event.redirectResponse.status,
+          headers: headers(event.redirectResponse.headers),
+          mimeType: event.redirectResponse.mimeType,
+        };
+        this.changed.set(previous.seq, previous);
+      }
+      if (!/^https?:/.test(event.request.url)) return;
+      const request: CapturedRequest = {
+        seq: this.sequence++,
+        timestamp: Date.now() - this.started,
+        method: event.request.method,
+        url: event.request.url,
+        headers: headers(event.request.headers),
+        body: event.request.postData,
+        resourceType: event.type ?? 'Other',
+      };
+      this.inflight.set(event.requestId, request);
+      this.changed.set(request.seq, request);
+      if (event.request.hasPostData && event.request.postData === undefined) {
+        this.track(async () => {
+          try {
+            const body = await this.command(
+              client.Network.getRequestPostData({ requestId: event.requestId }),
+            );
+            request.body = body.postData;
+          } catch {
+            this.errors.push({ seq: request.seq, message: 'Request body unavailable from CDP.' });
+          }
+          this.changed.set(request.seq, request);
+        });
+      }
+    });
+    client.Network.responseReceived((event) => {
+      if (this.closed) return;
+      const request = this.inflight.get(event.requestId);
+      if (!request) return;
+      request.response = {
+        status: event.response.status,
+        headers: headers(event.response.headers),
+        mimeType: event.response.mimeType,
+      };
+      this.changed.set(request.seq, request);
+    });
+    client.Network.loadingFinished((event) => {
+      if (this.closed) return;
+      const request = this.inflight.get(event.requestId);
+      if (!request) return;
+      this.inflight.delete(event.requestId);
+      this.track(async () => {
+        try {
+          const body = await this.command(
+            client.Network.getResponseBody({ requestId: event.requestId }),
+          );
+          if (request.response) {
+            request.response.body = body.base64Encoded
+              ? Buffer.from(body.body, 'base64').toString('utf8')
+              : body.body;
+          }
+        } catch {
+          this.errors.push({ seq: request.seq, message: 'Response body unavailable from CDP.' });
+        }
+        this.changed.set(request.seq, request);
+      });
+    });
+    client.Network.loadingFailed((event) => {
+      if (this.closed) return;
+      const request = this.inflight.get(event.requestId);
+      if (!request) return;
+      this.inflight.delete(event.requestId);
+      this.errors.push({ seq: request.seq, message: event.errorText });
+      this.changed.set(request.seq, request);
+    });
+  }
+
+  close(): void {
+    this.closed = true;
+    this.inflight.clear();
+    this.changed.clear();
+    this.errors = [];
+  }
+
+  async interact(
+    action: AuthBrowserAction,
+    clickExpression: (selector: string) => string,
+  ): Promise<AuthBrowserObservation> {
+    const { Input, Page } = this.client;
+    if (action.action === 'navigate') {
+      if (!/^https?:/.test(action.url)) throw new Error('Navigation requires an HTTP(S) URL.');
+      const result = await this.command(Page.navigate({ url: action.url }));
+      if (result.errorText) throw new Error(result.errorText);
+    } else if (action.action === 'click') {
+      const point = (await this.evaluate(clickExpression(action.selector))) as {
+        x?: number;
+        y?: number;
+        diagnostic?: unknown;
+      };
+      if (point.x === undefined || point.y === undefined)
+        throw new Error(`Click target unavailable: ${JSON.stringify(point.diagnostic)}`);
+      await this.command(
+        Input.dispatchMouseEvent({
+          type: 'mousePressed',
+          x: point.x,
+          y: point.y,
+          button: 'left',
+          clickCount: 1,
+        }),
+      );
+      await this.command(
+        Input.dispatchMouseEvent({
+          type: 'mouseReleased',
+          x: point.x,
+          y: point.y,
+          button: 'left',
+          clickCount: 1,
+        }),
+      );
+    } else if (action.action === 'fill' || action.action === 'select') {
+      await this.evaluate(`(() => {
+        const matches = document.querySelectorAll(${JSON.stringify(action.selector)});
+        if (matches.length !== 1) throw new Error('Expected exactly one input control');
+        const element = matches[0];
+        if (element.matches(':disabled')) throw new Error('Control is disabled');
+        element.focus();
+        if (${JSON.stringify(action.action)} === 'select') {
+          if (!(element instanceof HTMLSelectElement)) throw new Error('Control is not a select');
+          element.value = ${JSON.stringify(action.value)};
+          element.dispatchEvent(new Event('input', { bubbles: true }));
+          element.dispatchEvent(new Event('change', { bubbles: true }));
+        } else {
+          if (!(element instanceof HTMLInputElement || element instanceof HTMLTextAreaElement)) throw new Error('Control is not a text input');
+          element.select();
+        }
+      })()`);
+      if (action.action === 'fill') await this.command(Input.insertText({ text: action.value }));
+    } else if (action.action === 'press') {
+      const code = { Enter: 13, Tab: 9, Escape: 27, Backspace: 8 }[action.key];
+      await this.command(
+        Input.dispatchKeyEvent({
+          type: 'keyDown',
+          key: action.key,
+          windowsVirtualKeyCode: code,
+          ...(action.key === 'Enter' ? { text: '\r' } : {}),
+        }),
+      );
+      await this.command(
+        Input.dispatchKeyEvent({ type: 'keyUp', key: action.key, windowsVirtualKeyCode: code }),
+      );
+    }
+    // This is an observation interval, not a claim that the page has settled.
+    // The agent can inspect/wait again for slow responses or external actions.
+    await new Promise((resolve) =>
+      setTimeout(resolve, action.action === 'wait' ? action.milliseconds : 250),
+    );
+    const page = (await this.evaluate(`(() => {
+      const selector = (element) => {
+        if (element.id && document.querySelectorAll('#' + CSS.escape(element.id)).length === 1) return '#' + CSS.escape(element.id);
+        const parts = [];
+        for (let node = element; node && node.nodeType === 1; node = node.parentElement) {
+          const peers = node.parentElement ? [...node.parentElement.children].filter(p => p.tagName === node.tagName) : [node];
+          parts.unshift(node.tagName.toLowerCase() + ':nth-of-type(' + (peers.indexOf(node) + 1) + ')');
+        }
+        return parts.join(' > ');
+      };
+      const controls = [...document.querySelectorAll('input:not([type=hidden]),button,select,textarea,a[href],[role=button],[role=radio]')].filter(e => e.getClientRects().length);
+      return {
+        url: location.href, title: document.title, bodyText: (document.body?.innerText ?? '').slice(0, 20000),
+        controls: controls.slice(0, 100).map(e => ({ selector: selector(e), tag: e.tagName.toLowerCase(), type: e.getAttribute('type') || '', name: e.getAttribute('name') || '', text: (e.getAttribute('aria-label') || e.labels?.[0]?.innerText || e.innerText || '').slice(0, 300), disabled: e.matches(':disabled') })),
+        controlsTruncated: controls.length > 100
+      };
+    })()`)) as AuthBrowserObservation['page'];
+    await Promise.all([...this.bodyReads]);
+    const requests = structuredClone([...this.changed.values()]);
+    this.changed.clear();
+    const captureErrors = this.errors;
+    this.errors = [];
+    return { sourceId: this.sourceId, page, requests, captureErrors };
+  }
+
+  private track(work: () => Promise<void>): void {
+    const promise = work();
+    this.bodyReads.add(promise);
+    void promise.finally(() => this.bodyReads.delete(promise));
+  }
+
+  private async evaluate(expression: string): Promise<unknown> {
+    const result = await this.command(
+      this.client.Runtime.evaluate({ expression, returnByValue: true }),
+    );
+    if (result.exceptionDetails)
+      throw new Error(result.exceptionDetails.text || 'Browser interaction failed');
+    return result.result.value;
+  }
+
+  private async command<T>(promise: Promise<T>): Promise<T> {
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      return await Promise.race([
+        promise,
+        new Promise<never>((_, reject) => {
+          timer = setTimeout(
+            () => reject(new Error('Browser discovery CDP command timed out')),
+            this.timeoutMs,
+          );
+        }),
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+}
+
+function headers(values: Record<string, unknown>): Record<string, string> {
+  return Object.fromEntries(Object.entries(values).map(([key, value]) => [key, String(value)]));
+}