@canonmsg/codex-plugin 0.20.0 → 0.21.0

package/README.md

@@ -47,9 +47,9 @@ You do not need a git repo for host mode. The plugin passes `--skip-git-repo-che
 - Interrupt by terminating the active Codex turn
 - Tool/running status surfaced while Codex is working
 
-## Transport
+## Current limitation
 
-`canon-codex` drives Codex through the `codex app-server` JSON-RPC transport — the only supported transport. Canon routes native plan mode, runtime questions, approvals, tools, and live message deltas. A Codex CLI new enough to provide `codex app-server` is required.
+The stable `codex exec --json` surface exposes thinking state, tool activity, and completed assistant-message previews, but not token-by-token text deltas. v1 therefore publishes live progress and assistant-message snapshots without claiming true token streaming.
 
 Current Canon control truth for Codex host mode:
 
@@ -108,7 +108,7 @@ ps aux | rg canon-codex
 If you installed the package only inside this repo and not globally, run the built host directly:
 
 ```bash
-node adapters/codex-plugin/dist/host.js --cwd /path/to/project --full-auto
+node packages/codex-plugin/dist/host.js --cwd /path/to/project --full-auto
 ```
 
 If `canon-codex` starts but cannot find the `codex` binary, either fix your `PATH` or launch with an explicit binary path:
@@ -149,7 +149,7 @@ CANON_AGENT=frontend canon-codex --cwd ~/projects/frontend
 ## Development
 
 ```bash
-cd adapters/codex-plugin
+cd packages/codex-plugin
 npm install
 npm run build
 ```

package/dist/adapter.d.ts

@@ -0,0 +1,96 @@
+export type CodexSandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access';
+export type CodexApprovalPolicy = 'untrusted' | 'on-request' | 'never';
+export type CodexEvent = {
+    type: 'thread.started';
+    threadId: string;
+} | {
+    type: 'turn.started';
+} | {
+    type: 'message';
+    text: string;
+    itemId?: string;
+} | {
+    type: 'plan.updated';
+    text: string;
+} | {
+    type: 'waiting';
+    reason: string;
+} | {
+    type: 'command.started';
+    command: string;
+    itemId?: string;
+} | {
+    type: 'command.completed';
+    command: string;
+    output: string;
+    exitCode: number | null;
+    itemId?: string;
+} | {
+    type: 'turn.completed';
+    usage?: {
+        input_tokens?: number;
+        cached_input_tokens?: number;
+        output_tokens?: number;
+    };
+} | {
+    type: 'skills.changed';
+};
+export interface CodexServerRequest {
+    id: string | number;
+    method: string;
+    params: Record<string, unknown>;
+}
+export interface CodexRunTurnOptions {
+    planMode?: boolean;
+    onServerRequest?: (request: CodexServerRequest) => Promise<unknown>;
+}
+export interface CodexTurnResult {
+    threadId: string | null;
+    finalMessage: string | null;
+    exitCode: number | null;
+    interrupted: boolean;
+    errorText: string | null;
+}
+export declare class CodexConversationAdapter {
+    private readonly cwd;
+    private readonly codexBin;
+    private model;
+    private reasoningEffort;
+    private readonly sandbox;
+    private readonly legacyApprovalPolicy;
+    private readonly codexProfile;
+    private readonly addDirs;
+    private readonly configOverrides;
+    private readonly fullAuto;
+    private readonly bypassApprovalsAndSandbox;
+    private child;
+    private threadId;
+    private interruptTimer;
+    private interrupted;
+    constructor(opts: {
+        cwd: string;
+        threadId?: string | null;
+        codexBin?: string;
+        model?: string | null;
+        reasoningEffort?: string | null;
+        sandbox?: CodexSandboxMode | null;
+        approvalPolicy?: CodexApprovalPolicy | null;
+        codexProfile?: string | null;
+        addDirs?: string[];
+        configOverrides?: string[];
+        fullAuto?: boolean;
+        bypassApprovalsAndSandbox?: boolean;
+    });
+    getThreadId(): string | null;
+    clearThreadId(): void;
+    setModel(model: string | null): void;
+    /** Sets GPT reasoning effort, applied on the next turn via `-c model_reasoning_effort`. */
+    setReasoningEffort(effort: string | null): void;
+    isRunning(): boolean;
+    interrupt(): Promise<void>;
+    runTurn(prompt: string, onEvent: (event: CodexEvent) => void, onLog?: (line: string) => void, imagePaths?: readonly string[], extraAddDirs?: readonly string[], _options?: CodexRunTurnOptions): Promise<CodexTurnResult>;
+    private buildAddDirs;
+    private buildArgs;
+    private canResumeWithCurrentPolicy;
+    private clearActiveProcess;
+}

package/dist/adapter.js

@@ -0,0 +1,310 @@
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { isRecoverableCodexThreadError } from './error-format.js';
+export class CodexConversationAdapter {
+    cwd;
+    codexBin;
+    model;
+    reasoningEffort;
+    sandbox;
+    legacyApprovalPolicy;
+    codexProfile;
+    addDirs;
+    configOverrides;
+    fullAuto;
+    bypassApprovalsAndSandbox;
+    child = null;
+    threadId;
+    interruptTimer = null;
+    interrupted = false;
+    constructor(opts) {
+        this.cwd = opts.cwd;
+        this.threadId = opts.threadId ?? null;
+        this.codexBin = opts.codexBin ?? 'codex';
+        this.model = opts.model ?? null;
+        this.reasoningEffort = opts.reasoningEffort ?? null;
+        this.sandbox = opts.sandbox ?? null;
+        this.legacyApprovalPolicy = opts.approvalPolicy ?? null;
+        this.codexProfile = opts.codexProfile ?? null;
+        this.addDirs = opts.addDirs ?? [];
+        this.configOverrides = opts.configOverrides ?? [];
+        this.fullAuto = opts.fullAuto ?? false;
+        this.bypassApprovalsAndSandbox = opts.bypassApprovalsAndSandbox ?? false;
+    }
+    getThreadId() {
+        return this.threadId;
+    }
+    clearThreadId() {
+        this.threadId = null;
+    }
+    setModel(model) {
+        this.model = model;
+    }
+    /** Sets GPT reasoning effort, applied on the next turn via `-c model_reasoning_effort`. */
+    setReasoningEffort(effort) {
+        this.reasoningEffort = effort && effort.trim() ? effort.trim() : null;
+    }
+    isRunning() {
+        return this.child !== null;
+    }
+    async interrupt() {
+        if (!this.child)
+            return;
+        this.interrupted = true;
+        this.child.kill('SIGINT');
+        this.interruptTimer = setTimeout(() => {
+            if (this.child)
+                this.child.kill('SIGKILL');
+        }, 5_000);
+    }
+    async runTurn(prompt, onEvent, onLog, imagePaths = [], extraAddDirs = [], _options = {}) {
+        if (this.child) {
+            throw new Error('A Codex turn is already in progress for this conversation');
+        }
+        const args = this.buildArgs(prompt, imagePaths, extraAddDirs);
+        const child = spawn(this.codexBin, args, {
+            cwd: this.cwd,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        this.child = child;
+        this.interrupted = false;
+        let latestMessage = null;
+        let lastErrorText = null;
+        const stdout = createInterface({ input: child.stdout });
+        const stderr = createInterface({ input: child.stderr });
+        stdout.on('line', (line) => {
+            const event = parseEventLine(line);
+            if (!event)
+                return;
+            switch (event.type) {
+                case 'thread.started':
+                    this.threadId = event.thread_id;
+                    onEvent({ type: 'thread.started', threadId: event.thread_id });
+                    break;
+                case 'turn.started':
+                    onEvent({ type: 'turn.started' });
+                    break;
+                case 'item.started':
+                    if (event.item?.type === 'command_execution') {
+                        onEvent({
+                            type: 'command.started',
+                            command: String(event.item.command ?? ''),
+                            ...(typeof event.item.id === 'string' && event.item.id.trim()
+                                ? { itemId: event.item.id.trim() }
+                                : {}),
+                        });
+                    }
+                    break;
+                case 'item.completed':
+                    if (event.item?.type === 'agent_message') {
+                        latestMessage = normalizeMessageText(event.item.text);
+                        if (latestMessage) {
+                            onEvent({
+                                type: 'message',
+                                text: latestMessage,
+                                ...(typeof event.item.id === 'string' && event.item.id.trim()
+                                    ? { itemId: event.item.id.trim() }
+                                    : {}),
+                            });
+                        }
+                    }
+                    else if (event.item?.type === 'command_execution') {
+                        onEvent({
+                            type: 'command.completed',
+                            command: String(event.item.command ?? ''),
+                            output: String(event.item.aggregated_output ?? ''),
+                            exitCode: typeof event.item.exit_code === 'number' ? event.item.exit_code : null,
+                            ...(typeof event.item.id === 'string' && event.item.id.trim()
+                                ? { itemId: event.item.id.trim() }
+                                : {}),
+                        });
+                    }
+                    break;
+                case 'turn.completed':
+                    onEvent({ type: 'turn.completed', usage: event.usage });
+                    break;
+                case 'error':
+                    lastErrorText = normalizeErrorText(event.message) ?? lastErrorText;
+                    break;
+                case 'turn.failed':
+                    lastErrorText = normalizeErrorText(event.error?.message ?? event.message) ?? lastErrorText;
+                    break;
+                default:
+                    break;
+            }
+        });
+        stderr.on('line', (line) => {
+            const trimmed = line.trim();
+            if (!trimmed)
+                return;
+            if (isIgnorableCodexLog(trimmed))
+                return;
+            lastErrorText = trimmed;
+            if (isRecoverableCodexThreadError(trimmed))
+                return;
+            onLog?.(trimmed);
+        });
+        return await new Promise((resolve, reject) => {
+            child.on('error', (error) => {
+                this.clearActiveProcess();
+                reject(error);
+            });
+            child.on('close', (code) => {
+                stdout.close();
+                stderr.close();
+                const interrupted = this.interrupted || code === 130;
+                const result = {
+                    threadId: this.threadId,
+                    finalMessage: latestMessage,
+                    exitCode: code,
+                    interrupted,
+                    errorText: interrupted ? null : lastErrorText,
+                };
+                this.clearActiveProcess();
+                resolve(result);
+            });
+        });
+    }
+    buildAddDirs(extraAddDirs = []) {
+        const seen = new Set();
+        const dirs = [];
+        for (const value of [...this.addDirs, ...extraAddDirs]) {
+            const trimmed = value.trim();
+            if (!trimmed || seen.has(trimmed))
+                continue;
+            seen.add(trimmed);
+            dirs.push(value);
+        }
+        return dirs;
+    }
+    buildArgs(prompt, imagePaths = [], extraAddDirs = []) {
+        if (this.threadId && this.canResumeWithCurrentPolicy()) {
+            const args = ['exec', 'resume', '--json', '--skip-git-repo-check'];
+            if (this.model) {
+                args.push('-m', this.model);
+            }
+            if (this.codexProfile) {
+                args.push('-p', this.codexProfile);
+            }
+            for (const configOverride of this.configOverrides) {
+                args.push('-c', configOverride);
+            }
+            if (this.reasoningEffort) {
+                args.push('-c', `model_reasoning_effort="${this.reasoningEffort}"`);
+            }
+            for (const addDir of this.buildAddDirs(extraAddDirs)) {
+                args.push('--add-dir', addDir);
+            }
+            if (this.fullAuto) {
+                args.push('--full-auto');
+            }
+            if (this.bypassApprovalsAndSandbox) {
+                args.push('--dangerously-bypass-approvals-and-sandbox');
+            }
+            for (const imagePath of imagePaths) {
+                args.push('-i', imagePath);
+            }
+            if (imagePaths.length > 0) {
+                args.push('--');
+            }
+            args.push(this.threadId, prompt);
+            return args;
+        }
+        if (this.threadId) {
+            this.threadId = null;
+        }
+        const args = ['exec', '--json', '--color', 'never', '-C', this.cwd, '--skip-git-repo-check'];
+        const execMode = resolveExecMode({
+            sandbox: this.sandbox,
+            fullAuto: this.fullAuto,
+            bypassApprovalsAndSandbox: this.bypassApprovalsAndSandbox,
+        });
+        if (this.model) {
+            args.push('-m', this.model);
+        }
+        if (this.sandbox) {
+            args.push('-s', this.sandbox);
+        }
+        if (this.codexProfile) {
+            args.push('-p', this.codexProfile);
+        }
+        for (const addDir of this.buildAddDirs(extraAddDirs)) {
+            args.push('--add-dir', addDir);
+        }
+        for (const configOverride of this.configOverrides) {
+            args.push('-c', configOverride);
+        }
+        if (this.reasoningEffort) {
+            args.push('-c', `model_reasoning_effort="${this.reasoningEffort}"`);
+        }
+        if (execMode.fullAuto) {
+            args.push('--full-auto');
+        }
+        if (execMode.bypassApprovalsAndSandbox) {
+            args.push('--dangerously-bypass-approvals-and-sandbox');
+        }
+        for (const imagePath of imagePaths) {
+            args.push('-i', imagePath);
+        }
+        if (imagePaths.length > 0) {
+            args.push('--');
+        }
+        args.push(prompt);
+        return args;
+    }
+    canResumeWithCurrentPolicy() {
+        if (this.bypassApprovalsAndSandbox || this.fullAuto) {
+            return true;
+        }
+        return this.sandbox === null;
+    }
+    clearActiveProcess() {
+        if (this.interruptTimer) {
+            clearTimeout(this.interruptTimer);
+            this.interruptTimer = null;
+        }
+        this.child = null;
+    }
+}
+function parseEventLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{'))
+        return null;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+function normalizeMessageText(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.trim();
+    return text ? text : null;
+}
+function normalizeErrorText(value) {
+    if (typeof value !== 'string')
+        return null;
+    const text = value.trim();
+    return text ? text : null;
+}
+function resolveExecMode(input) {
+    if (input.bypassApprovalsAndSandbox) {
+        return { fullAuto: false, bypassApprovalsAndSandbox: true };
+    }
+    if (input.fullAuto) {
+        return { fullAuto: true, bypassApprovalsAndSandbox: false };
+    }
+    return { fullAuto: false, bypassApprovalsAndSandbox: false };
+}
+function isIgnorableCodexLog(line) {
+    return [
+        'Reading additional input from stdin...',
+        'ignoring interface.defaultPrompt',
+        'state db discrepancy during find_thread_path_by_id_str_in_subdir',
+        'failed to open state db',
+        'failed to initialize state runtime',
+        'Failed to delete shell snapshot',
+    ].some((pattern) => line.includes(pattern));
+}

package/dist/app-server-adapter.d.ts

@@ -1,57 +1,4 @@
-export type CodexSandboxMode = 'read-only' | 'workspace-write' | 'danger-full-access';
-export type CodexApprovalPolicy = 'untrusted' | 'on-request' | 'never';
-export type CodexEvent = {
-    type: 'thread.started';
-    threadId: string;
-} | {
-    type: 'turn.started';
-} | {
-    type: 'message';
-    text: string;
-    delta?: string;
-    itemId?: string;
-} | {
-    type: 'plan.updated';
-    text: string;
-} | {
-    type: 'waiting';
-    reason: string;
-} | {
-    type: 'command.started';
-    command: string;
-    itemId?: string;
-} | {
-    type: 'command.completed';
-    command: string;
-    output: string;
-    exitCode: number | null;
-    itemId?: string;
-} | {
-    type: 'turn.completed';
-    usage?: {
-        input_tokens?: number;
-        cached_input_tokens?: number;
-        output_tokens?: number;
-    };
-} | {
-    type: 'skills.changed';
-};
-export interface CodexServerRequest {
-    id: string | number;
-    method: string;
-    params: Record<string, unknown>;
-}
-export interface CodexRunTurnOptions {
-    planMode?: boolean;
-    onServerRequest?: (request: CodexServerRequest) => Promise<unknown>;
-}
-export interface CodexTurnResult {
-    threadId: string | null;
-    finalMessage: string | null;
-    exitCode: number | null;
-    interrupted: boolean;
-    errorText: string | null;
-}
+import type { CodexApprovalPolicy, CodexEvent, CodexRunTurnOptions, CodexSandboxMode, CodexTurnResult } from './adapter.js';
 export type JsonRecord = Record<string, unknown>;
 export interface CodexSkillMetadata {
     name: string;
@@ -67,6 +14,7 @@ export declare class CodexAppServerAdapter {
     private model;
     private reasoningEffort;
     private readonly sandbox;
+    private readonly legacyApprovalPolicy;
     private readonly addDirs;
     private readonly configOverrides;
     private readonly fullAuto;
@@ -91,7 +39,6 @@ export declare class CodexAppServerAdapter {
     private skillsCache;
     private messageTextByItem;
     private planText;
-    private traceTurnEpochMs;
     constructor(opts: {
         cwd: string;
         threadId?: string | null;
@@ -99,6 +46,7 @@ export declare class CodexAppServerAdapter {
         model?: string | null;
         reasoningEffort?: string | null;
         sandbox?: CodexSandboxMode | null;
+        approvalPolicy?: CodexApprovalPolicy | null;
         addDirs?: string[];
         configOverrides?: string[];
         fullAuto?: boolean;
@@ -136,18 +84,9 @@ export declare class CodexAppServerAdapter {
     private handleLine;
     private handleServerRequest;
     private handleNotification;
-    /**
-     * The turn's final message is the JOIN of every agentMessage item, in
-     * insertion order — not just the last item. The streamed turn trail folds
-     * all items (one text segment per item), so the final text must match the
-     * streamed/folded text or the app renders the turn twice.
-     */
-    private joinedAgentMessageText;
     private isCurrentThreadNotification;
     private resolveCurrentTurn;
     private clearActiveTurn;
     private sendRequest;
     private write;
-    private trace;
-    private traceLine;
 }

package/dist/app-server-adapter.js

@@ -6,6 +6,7 @@ export class CodexAppServerAdapter {
     model;
     reasoningEffort;
     sandbox;
+    legacyApprovalPolicy;
     addDirs;
     configOverrides;
     fullAuto;
@@ -30,7 +31,6 @@ export class CodexAppServerAdapter {
     skillsCache = null;
     messageTextByItem = new Map();
     planText = '';
-    traceTurnEpochMs = null;
     constructor(opts) {
         this.cwd = opts.cwd;
         this.threadId = opts.threadId ?? null;
@@ -38,6 +38,7 @@ export class CodexAppServerAdapter {
         this.model = opts.model ?? null;
         this.reasoningEffort = opts.reasoningEffort ?? null;
         this.sandbox = opts.sandbox ?? null;
+        this.legacyApprovalPolicy = opts.approvalPolicy ?? null;
         this.addDirs = opts.addDirs ?? [];
         this.configOverrides = opts.configOverrides ?? [];
         this.fullAuto = opts.fullAuto ?? false;
@@ -116,8 +117,6 @@ export class CodexAppServerAdapter {
         this.interrupted = false;
         this.messageTextByItem.clear();
         this.planText = '';
-        this.traceTurnEpochMs = Date.now();
-        this.trace('turn/run begin');
         try {
             if (this.threadId && this.loadedThreadId !== this.threadId) {
                 const resumed = await this.sendRequest('thread/resume', {
@@ -159,11 +158,9 @@ export class CodexAppServerAdapter {
                 this.currentTurnReject = reject;
             });
             turnPromise.catch(() => { });
-            const turnInput = await this.buildTurnInput(prompt, imagePaths);
-            this.trace('turn/start sent');
             const turnStarted = await this.sendRequest('turn/start', {
                 threadId: this.threadId,
-                input: turnInput,
+                input: await this.buildTurnInput(prompt, imagePaths),
                 ...(this.model ? { model: this.model } : {}),
                 ...this.sandboxPolicyPayload(_extraAddDirs),
                 collaborationMode: {
@@ -175,7 +172,6 @@ export class CodexAppServerAdapter {
                     },
                 },
             });
-            this.trace('turn/start ack');
             const turn = turnStarted.turn;
             if (this.currentTurnResolve) {
                 this.currentTurnId = readString(turn, 'id') ?? null;
@@ -191,7 +187,7 @@ export class CodexAppServerAdapter {
     resolveApprovalPolicy() {
         if (this.bypassApprovalsAndSandbox || this.fullAuto)
             return 'never';
-        return null;
+        return this.legacyApprovalPolicy;
     }
     configPayload() {
         const config = {};
@@ -326,7 +322,6 @@ export class CodexAppServerAdapter {
         const message = parseJson(line);
         if (!message)
             return;
-        this.traceLine(line, message);
         if ('id' in message && ('result' in message || 'error' in message) && !('method' in message)) {
             const id = Number(message.id);
             const pending = this.pending.get(id);
@@ -398,9 +393,9 @@ export class CodexAppServerAdapter {
             const delta = readRawString(params, 'delta') ?? '';
             const next = `${this.messageTextByItem.get(itemId) ?? ''}${delta}`;
             this.messageTextByItem.set(itemId, next);
-            this.currentFinalMessage = this.joinedAgentMessageText() ?? this.currentFinalMessage;
+            this.currentFinalMessage = next.trim() ? next : this.currentFinalMessage;
             if (next.trim())
-                this.currentOnEvent?.({ type: 'message', text: next, delta, itemId });
+                this.currentOnEvent?.({ type: 'message', text: next, itemId });
             return;
         }
         if (method === 'turn/plan/updated') {
@@ -437,8 +432,7 @@ export class CodexAppServerAdapter {
                 const itemId = readString(item, 'id');
                 const text = readString(item, 'text');
                 if (text) {
-                    this.messageTextByItem.set(itemId ?? 'agent-message', text);
-                    this.currentFinalMessage = this.joinedAgentMessageText() ?? text;
+                    this.currentFinalMessage = text;
                     this.currentOnEvent?.({
                         type: 'message',
                         text,
@@ -472,7 +466,6 @@ export class CodexAppServerAdapter {
             return;
         }
         if (method === 'turn/completed') {
-            this.trace('turn/completed notification');
             const turn = params.turn;
             const status = turn?.status;
             if (isRecord(status) && status.type === 'failed') {
@@ -493,18 +486,6 @@ export class CodexAppServerAdapter {
             this.currentErrorText = stringifyPreview(params);
         }
     }
-    /**
-     * The turn's final message is the JOIN of every agentMessage item, in
-     * insertion order — not just the last item. The streamed turn trail folds
-     * all items (one text segment per item), so the final text must match the
-     * streamed/folded text or the app renders the turn twice.
-     */
-    joinedAgentMessageText() {
-        const joined = [...this.messageTextByItem.values()]
-            .filter((text) => text.trim())
-            .join('\n\n');
-        return joined.trim() ? joined : null;
-    }
     isCurrentThreadNotification(params) {
         const threadId = readNotificationThreadId(params);
         if (threadId && this.threadId && threadId !== this.threadId)
@@ -536,7 +517,6 @@ export class CodexAppServerAdapter {
         this.currentErrorText = null;
         this.messageTextByItem.clear();
         this.planText = '';
-        this.traceTurnEpochMs = null;
     }
     sendRequest(method, params) {
         const id = this.requestSeq++;
@@ -556,33 +536,6 @@ export class CodexAppServerAdapter {
             throw new Error('Codex app-server is not running');
         this.child.stdin.write(`${JSON.stringify(message)}\n`);
     }
-    trace(message) {
-        if (!isCodexTraceEnabled())
-            return;
-        const elapsedMs = this.traceTurnEpochMs === null ? 0 : Date.now() - this.traceTurnEpochMs;
-        console.error(`[canon-codex-trace] +${elapsedMs}ms ${message}`);
-    }
-    traceLine(line, message) {
-        if (!isCodexTraceEnabled())
-            return;
-        const method = typeof message.method === 'string' ? message.method : null;
-        if (!method) {
-            const id = 'id' in message ? ` id=${String(message.id)}` : '';
-            this.trace(`line bytes=${line.length} response${id}`);
-            return;
-        }
-        if (method === 'item/agentMessage/delta') {
-            const params = isRecord(message.params) ? message.params : {};
-            const itemId = readString(params, 'itemId') ?? 'agent-message';
-            const delta = readRawString(params, 'delta') ?? '';
-            this.trace(`line bytes=${line.length} method=${method} itemId=${itemId} deltaLen=${delta.length}`);
-            return;
-        }
-        this.trace(`line bytes=${line.length} method=${method}`);
-    }
-}
-function isCodexTraceEnabled() {
-    return process.env.CANON_CODEX_TRACE_EVENTS === '1';
 }
 function parseJson(line) {
     try {