@ornexus/neocortex 4.60.72 → 4.60.73

package/packages/client/dist/runner/local-console.js

@@ -1,13 +1,396 @@
-import{createHash as $}from"node:crypto";import{existsSync as J,mkdirSync as x,rmSync as N}from"node:fs";import{createConnection as P,createServer as B}from"node:net";import{tmpdir as F}from"node:os";import{dirname as H,join as M,resolve as V}from"node:path";import{createInterface as U}from"node:readline";const a=Object.freeze({OK:"continuity-ok",ATTACHED:"jobs-console-attached",NOT_ATTACHED:"jobs-console-not-attached",INVALID_SELECTOR:"jobs-console-invalid-selector",IPC_UNAVAILABLE:"jobs-console-ipc-unavailable",STDIN_CONFIRMATION_REQUIRED:"jobs-console-stdin-confirmation-required",STDIN_DISCARDED:"jobs-console-stdin-discarded",LOCAL_CONTROL_APPLIED:"jobs-console-local-control-applied",LOCAL_CONTROL_FAILED:"jobs-console-local-control-failed"}),K=/^@?(job-J\d{3,})$/i,q=/^job-J\d{3,}$/i,z=250;function re(t){return w(t).kind!=="not-console"}function w(t){const e=t.trim().split(/\s+/).filter(Boolean);if(e.length<2)return{kind:"not-console"};const r=e[0]?.replace(/^\*/,"").toLowerCase(),c=e[1]?.toLowerCase();if(r!=="jobs"||c!=="console")return{kind:"not-console"};if(e.length!==3)return{kind:"invalid",reasonCode:a.INVALID_SELECTOR};const s=e[2]?.match(K);return s?{kind:"valid",jobId:O(s[1])}:{kind:"invalid",reasonCode:a.INVALID_SELECTOR}}function D(t,e){const r=V(t&&t.trim().length>0?t:process.cwd()),c=$("sha256").update(r).digest("hex").slice(0,24),s=G(O(e));return process.platform==="win32"?`\\\\.\\pipe\\neocortex-job-console-${c}-${s}`:M(F(),"neocortex-job-console",c,`${s}.sock`)}function se(t){const e=O(t.jobId),r=t.socketPath??D(t.projectRoot,e),c=new Set;let s,I=!1;const b=(o,n)=>{o.destroyed||o.write(`${JSON.stringify(n)}
-`)},p=o=>{for(const n of c)b(n,o)},m=(o,n)=>{if(n.type==="close"){o.end();return}if(n.type==="stdin"){const f=h(n.data);if(!f){b(o,{type:"stdin_ack",ok:!1,reasonCode:a.IPC_UNAVAILABLE,publicSafe:!0});return}try{t.writeStdin?.(f),b(o,{type:"stdin_ack",ok:!0,reasonCode:a.OK,publicSafe:!0})}catch{b(o,{type:"stdin_ack",ok:!1,reasonCode:a.IPC_UNAVAILABLE,publicSafe:!0})}return}if(n.type==="control"){const f=W(n.action);let l=!1;try{l=!!(f&&t.signalProcess?.(f))}catch{l=!1}b(o,{type:"control_ack",action:n.action,ok:l,reasonCode:l?a.LOCAL_CONTROL_APPLIED:a.LOCAL_CONTROL_FAILED,publicSafe:!0})}};return{jobId:e,socketPath:r,async start(){if(I)return{ok:!0,reasonCode:a.OK,publicSafe:!0};if(!q.test(e))return{ok:!1,reasonCode:a.INVALID_SELECTOR,publicSafe:!0};try{return process.platform!=="win32"&&(x(H(r),{recursive:!0,mode:448}),J(r)&&N(r,{force:!0})),s=B(o=>{c.add(o),o.setEncoding("utf8"),b(o,{type:"attached",jobId:e,...t.attemptId?{attemptId:t.attemptId}:{},...t.executionId?{executionId:t.executionId}:{},serverHeldStream:!1,publicSafe:!0});let n="";o.on("data",f=>{n+=f;const l=n.split(`
-`);n=l.pop()??"";for(const C of l){const S=Q(C);S&&m(o,S)}}),o.on("close",()=>c.delete(o)),o.on("error",()=>c.delete(o))}),await new Promise((o,n)=>{s?.once("error",n),s?.listen(r,()=>o())}),I=!0,{ok:!0,reasonCode:a.OK,publicSafe:!0}}catch{return{ok:!1,reasonCode:a.IPC_UNAVAILABLE,publicSafe:!0}}},broadcastStdout(o){p(g("stdout",o))},broadcastStderr(o){p(g("stderr",o))},close(o={}){p({type:"exit",exitCode:o.exitCode??null,signal:o.signal??null,publicSafe:!0});for(const n of c)n.end();c.clear();try{s?.close()}catch{}if(process.platform!=="win32")try{N(r,{force:!0})}catch{}I=!1}}}async function ae(t){const e=t.stdout??process.stdout,r=t.stderr??process.stderr,c=t.stdin??process.stdin,s=w(t.args);if(s.kind==="not-console")return A("invalid",1,void 0,[a.INVALID_SELECTOR]);if(s.kind==="invalid"){const p=A("invalid",1,void 0,[s.reasonCode]);return E(e,p,t.format),p}const I=D(t.projectRoot,s.jobId),b=Math.max(10,Math.min(5e3,Math.floor(t.connectTimeoutMs??z)));return await new Promise(p=>{const m=P(I);let o=!1,n=!1,f="",l;const C=new Set;let S=()=>{};const L=setTimeout(()=>{if(o||n)return;n=!0,m.destroy();const i=A("not-attached",0,s.jobId,[a.NOT_ATTACHED]);E(e,i,t.format),p(i)},b),y=(i,u=0)=>{n||(n=!0,clearTimeout(L),S(),m.end(),p(A(i,u,s.jobId,Array.from(C))))},T=i=>{m.destroyed||m.write(`${JSON.stringify(i)}
-`)},R=i=>{T({type:"control",action:i})},_=U({input:c,terminal:!1}),j=i=>{if(!o)return;const u=i.trim();if(l!==void 0){u==="yes"?T({type:"stdin",data:Buffer.from(`${l}
-`,"utf8").toString("base64"),encoding:"base64"}):(C.add(a.STDIN_DISCARDED),e.write(`[jobs-console] stdin discarded; explicit confirmation was not provided.
-`)),l=void 0;return}if(u==="/quit"){T({type:"close"}),y("attached",0);return}if(u==="/pause"||u==="/resume"||u==="/cancel"){R(u.slice(1));return}l=i,C.add(a.STDIN_CONFIRMATION_REQUIRED),e.write(`[jobs-console] confirm stdin: type yes to send this line to the local process; anything else discards it.
-`)};S=()=>{_.removeListener("line",j),_.close()},_.on("line",j),m.on("connect",()=>{o=!0,clearTimeout(L),C.add(a.ATTACHED),e.write(`[jobs-console] attached job=${s.jobId} serverHeldStream=false serverAccessToLocalhost=false controls=/pause,/resume,/cancel,/quit
-`)}),m.on("data",i=>{f+=i.toString("utf8");const u=f.split(`
-`);f=u.pop()??"";for(const v of u){const d=Z(v);d&&(d.type==="stdout"?e.write(h(d.data)??Buffer.alloc(0)):d.type==="stderr"?r.write(h(d.data)??Buffer.alloc(0)):d.type==="control_ack"?(C.add(d.reasonCode),e.write(`[jobs-console] control ${d.action} ${d.ok?"applied":"failed"} reason=${d.reasonCode}
-`)):d.type==="stdin_ack"?(C.add(d.reasonCode),e.write(`[jobs-console] stdin ${d.ok?"sent":"failed"} reason=${d.reasonCode}
-`)):d.type==="exit"&&y("attached",0))}}),m.on("error",()=>{if(o||n){C.add(a.IPC_UNAVAILABLE),y("error",1);return}n=!0,clearTimeout(L),S();const i=A("not-attached",0,s.jobId,[a.NOT_ATTACHED]);E(e,i,t.format),p(i)}),m.on("close",()=>{!n&&o&&y("attached",0)})})}function O(t){const e=t.replace(/^@/,""),r=e.match(/^job-J(\d{3,})$/i);return r?`job-J${r[1]}`:e}function G(t){return t.replace(/[^A-Za-z0-9._-]+/g,"-").slice(0,80)||"job"}function g(t,e){return{type:t,data:Buffer.from(e).toString("base64"),encoding:"base64"}}function Q(t){const e=k(t);if(e){if(e.type==="stdin"&&typeof e.data=="string"&&e.encoding==="base64"||e.type==="control"&&(e.action==="pause"||e.action==="resume"||e.action==="cancel"))return e;if(e.type==="close")return{type:"close"}}}function Z(t){const e=k(t);if(!(!e||typeof e.type!="string"))return e}function k(t){if(t.trim())try{const e=JSON.parse(t);return typeof e=="object"&&e!==null&&!Array.isArray(e)?e:void 0}catch{return}}function h(t){try{return Buffer.from(t,"base64")}catch{return}}function W(t){return t==="pause"?process.platform==="win32"?void 0:"SIGSTOP":t==="resume"?process.platform==="win32"?void 0:"SIGCONT":"SIGTERM"}function A(t,e,r,c){return{status:t,exitCode:e,...r?{jobId:r}:{},reasonCodes:c.length>0?Array.from(new Set(c)):[a.OK],serverHeldStream:!1,serverAccessToLocalhost:!1,publicSafe:!0}}function E(t,e,r="plain"){if(r==="json"){t.write(`${JSON.stringify({type:"jobs_console_status",...e})}
-`);return}const c=e.jobId?` job=${e.jobId}`:"";t.write(`[jobs-console] status=${e.status}${c} serverHeldStream=false serverAccessToLocalhost=false reasons=${e.reasonCodes.join(",")}
-`)}export{a as LOCAL_JOBS_CONSOLE_REASON_CODES,se as createLocalJobConsoleServer,re as isLocalJobsConsoleArgs,D as localJobConsoleSocketPath,w as parseLocalJobsConsoleArgs,ae as runLocalJobsConsoleCommand};
+/**
+ * @license FSL-1.1
+ * Copyright (c) 2026 OrNexus AI
+ *
+ * P197.03 -- local Plane B jobs console attach surface.
+ *
+ * Raw stdout/stderr and stdin are intentionally scoped to an operator-local IPC
+ * hop between the runner-owned child process and the foreground CLI. Nothing in
+ * this file persists raw output, PIDs, TTY names, file descriptors or socket paths
+ * to continuity storage or server-bound metadata.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, rmSync } from 'node:fs';
+import { createConnection, createServer } from 'node:net';
+import { tmpdir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+export const LOCAL_JOBS_CONSOLE_REASON_CODES = Object.freeze({
+    OK: 'continuity-ok',
+    ATTACHED: 'jobs-console-attached',
+    NOT_ATTACHED: 'jobs-console-not-attached',
+    INVALID_SELECTOR: 'jobs-console-invalid-selector',
+    IPC_UNAVAILABLE: 'jobs-console-ipc-unavailable',
+    STDIN_CONFIRMATION_REQUIRED: 'jobs-console-stdin-confirmation-required',
+    STDIN_DISCARDED: 'jobs-console-stdin-discarded',
+    LOCAL_CONTROL_APPLIED: 'jobs-console-local-control-applied',
+    LOCAL_CONTROL_FAILED: 'jobs-console-local-control-failed',
+});
+const JOB_SELECTOR_PATTERN = /^@?(job-J\d{3,})$/i;
+const SAFE_JOB_ID_PATTERN = /^job-J\d{3,}$/i;
+const DEFAULT_CONSOLE_CONNECT_TIMEOUT_MS = 250;
+export function isLocalJobsConsoleArgs(args) {
+    return parseLocalJobsConsoleArgs(args).kind !== 'not-console';
+}
+export function parseLocalJobsConsoleArgs(args) {
+    const tokens = args.trim().split(/\s+/).filter(Boolean);
+    if (tokens.length < 2)
+        return { kind: 'not-console' };
+    const command = tokens[0]?.replace(/^\*/, '').toLowerCase();
+    const operation = tokens[1]?.toLowerCase();
+    if (command !== 'jobs' || operation !== 'console')
+        return { kind: 'not-console' };
+    if (tokens.length !== 3)
+        return { kind: 'invalid', reasonCode: LOCAL_JOBS_CONSOLE_REASON_CODES.INVALID_SELECTOR };
+    const match = tokens[2]?.match(JOB_SELECTOR_PATTERN);
+    if (!match)
+        return { kind: 'invalid', reasonCode: LOCAL_JOBS_CONSOLE_REASON_CODES.INVALID_SELECTOR };
+    return { kind: 'valid', jobId: canonicalJobId(match[1]) };
+}
+export function localJobConsoleSocketPath(projectRoot, jobId) {
+    const root = resolve(projectRoot && projectRoot.trim().length > 0 ? projectRoot : process.cwd());
+    const rootHash = createHash('sha256').update(root).digest('hex').slice(0, 24);
+    const safeJobId = sanitizeSocketToken(canonicalJobId(jobId));
+    if (process.platform === 'win32')
+        return `\\\\.\\pipe\\neocortex-job-console-${rootHash}-${safeJobId}`;
+    return join(tmpdir(), 'neocortex-job-console', rootHash, `${safeJobId}.sock`);
+}
+export function createLocalJobConsoleServer(options) {
+    const jobId = canonicalJobId(options.jobId);
+    const socketPath = options.socketPath ?? localJobConsoleSocketPath(options.projectRoot, jobId);
+    const sockets = new Set();
+    let server;
+    let started = false;
+    const writeFrame = (socket, frame) => {
+        if (socket.destroyed)
+            return;
+        socket.write(`${JSON.stringify(frame)}\n`);
+    };
+    const broadcast = (frame) => {
+        for (const socket of sockets)
+            writeFrame(socket, frame);
+    };
+    const handleClientFrame = (socket, frame) => {
+        if (frame.type === 'close') {
+            socket.end();
+            return;
+        }
+        if (frame.type === 'stdin') {
+            const chunk = decodeBase64Frame(frame.data);
+            if (!chunk) {
+                writeFrame(socket, { type: 'stdin_ack', ok: false, reasonCode: LOCAL_JOBS_CONSOLE_REASON_CODES.IPC_UNAVAILABLE, publicSafe: true });
+                return;
+            }
+            try {
+                options.writeStdin?.(chunk);
+                writeFrame(socket, { type: 'stdin_ack', ok: true, reasonCode: LOCAL_JOBS_CONSOLE_REASON_CODES.OK, publicSafe: true });
+            }
+            catch {
+                writeFrame(socket, { type: 'stdin_ack', ok: false, reasonCode: LOCAL_JOBS_CONSOLE_REASON_CODES.IPC_UNAVAILABLE, publicSafe: true });
+            }
+            return;
+        }
+        if (frame.type === 'control') {
+            const signal = signalForControl(frame.action);
+            let ok = false;
+            try {
+                ok = Boolean(signal && options.signalProcess?.(signal));
+            }
+            catch {
+                ok = false;
+            }
+            writeFrame(socket, {
+                type: 'control_ack',
+                action: frame.action,
+                ok,
+                reasonCode: ok
+                    ? LOCAL_JOBS_CONSOLE_REASON_CODES.LOCAL_CONTROL_APPLIED
+                    : LOCAL_JOBS_CONSOLE_REASON_CODES.LOCAL_CONTROL_FAILED,
+                publicSafe: true,
+            });
+        }
+    };
+    return {
+        jobId,
+        socketPath,
+        async start() {
+            if (started)
+                return { ok: true, reasonCode: LOCAL_JOBS_CONSOLE_REASON_CODES.OK, publicSafe: true };
+            if (!SAFE_JOB_ID_PATTERN.test(jobId)) {
+                return { ok: false, reasonCode: LOCAL_JOBS_CONSOLE_REASON_CODES.INVALID_SELECTOR, publicSafe: true };
+            }
+            try {
+                if (process.platform !== 'win32') {
+                    mkdirSync(dirname(socketPath), { recursive: true, mode: 0o700 });
+                    if (existsSync(socketPath))
+                        rmSync(socketPath, { force: true });
+                }
+                server = createServer((socket) => {
+                    sockets.add(socket);
+                    socket.setEncoding('utf8');
+                    writeFrame(socket, {
+                        type: 'attached',
+                        jobId,
+                        ...(options.attemptId ? { attemptId: options.attemptId } : {}),
+                        ...(options.executionId ? { executionId: options.executionId } : {}),
+                        serverHeldStream: false,
+                        publicSafe: true,
+                    });
+                    let buffer = '';
+                    socket.on('data', (chunk) => {
+                        buffer += chunk;
+                        const lines = buffer.split('\n');
+                        buffer = lines.pop() ?? '';
+                        for (const line of lines) {
+                            const parsed = parseClientFrame(line);
+                            if (parsed)
+                                handleClientFrame(socket, parsed);
+                        }
+                    });
+                    socket.on('close', () => sockets.delete(socket));
+                    socket.on('error', () => sockets.delete(socket));
+                });
+                await new Promise((resolvePromise, rejectPromise) => {
+                    server?.once('error', rejectPromise);
+                    server?.listen(socketPath, () => resolvePromise());
+                });
+                started = true;
+                return { ok: true, reasonCode: LOCAL_JOBS_CONSOLE_REASON_CODES.OK, publicSafe: true };
+            }
+            catch {
+                return { ok: false, reasonCode: LOCAL_JOBS_CONSOLE_REASON_CODES.IPC_UNAVAILABLE, publicSafe: true };
+            }
+        },
+        broadcastStdout(chunk) {
+            broadcast(rawChunkFrame('stdout', chunk));
+        },
+        broadcastStderr(chunk) {
+            broadcast(rawChunkFrame('stderr', chunk));
+        },
+        close(exit = {}) {
+            broadcast({ type: 'exit', exitCode: exit.exitCode ?? null, signal: exit.signal ?? null, publicSafe: true });
+            for (const socket of sockets)
+                socket.end();
+            sockets.clear();
+            try {
+                server?.close();
+            }
+            catch {
+                // best effort cleanup only
+            }
+            if (process.platform !== 'win32') {
+                try {
+                    rmSync(socketPath, { force: true });
+                }
+                catch { /* best effort */ }
+            }
+            started = false;
+        },
+    };
+}
+export async function runLocalJobsConsoleCommand(options) {
+    const stdout = options.stdout ?? process.stdout;
+    const stderr = options.stderr ?? process.stderr;
+    const input = options.stdin ?? process.stdin;
+    const parsed = parseLocalJobsConsoleArgs(options.args);
+    if (parsed.kind === 'not-console') {
+        return publicConsoleResult('invalid', 1, undefined, [LOCAL_JOBS_CONSOLE_REASON_CODES.INVALID_SELECTOR]);
+    }
+    if (parsed.kind === 'invalid') {
+        const result = publicConsoleResult('invalid', 1, undefined, [parsed.reasonCode]);
+        writeConsoleStatus(stdout, result, options.format);
+        return result;
+    }
+    const socketPath = localJobConsoleSocketPath(options.projectRoot, parsed.jobId);
+    const connectTimeoutMs = Math.max(10, Math.min(5_000, Math.floor(options.connectTimeoutMs ?? DEFAULT_CONSOLE_CONNECT_TIMEOUT_MS)));
+    return await new Promise((resolvePromise) => {
+        const socket = createConnection(socketPath);
+        let attached = false;
+        let settled = false;
+        let buffer = '';
+        let pendingStdin;
+        const reasonCodes = new Set();
+        let cleanupInput = () => { };
+        const timer = setTimeout(() => {
+            if (attached || settled)
+                return;
+            settled = true;
+            socket.destroy();
+            const result = publicConsoleResult('not-attached', 0, parsed.jobId, [LOCAL_JOBS_CONSOLE_REASON_CODES.NOT_ATTACHED]);
+            writeConsoleStatus(stdout, result, options.format);
+            resolvePromise(result);
+        }, connectTimeoutMs);
+        const finish = (status, exitCode = 0) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            cleanupInput();
+            socket.end();
+            resolvePromise(publicConsoleResult(status, exitCode, parsed.jobId, Array.from(reasonCodes)));
+        };
+        const sendFrame = (frame) => {
+            if (!socket.destroyed)
+                socket.write(`${JSON.stringify(frame)}\n`);
+        };
+        const sendControl = (action) => {
+            sendFrame({ type: 'control', action });
+        };
+        const readline = createInterface({ input, terminal: false });
+        const onLine = (line) => {
+            if (!attached)
+                return;
+            const trimmed = line.trim();
+            if (pendingStdin !== undefined) {
+                if (trimmed === 'yes') {
+                    sendFrame({ type: 'stdin', data: Buffer.from(`${pendingStdin}\n`, 'utf8').toString('base64'), encoding: 'base64' });
+                }
+                else {
+                    reasonCodes.add(LOCAL_JOBS_CONSOLE_REASON_CODES.STDIN_DISCARDED);
+                    stdout.write('[jobs-console] stdin discarded; explicit confirmation was not provided.\n');
+                }
+                pendingStdin = undefined;
+                return;
+            }
+            if (trimmed === '/quit') {
+                sendFrame({ type: 'close' });
+                finish('attached', 0);
+                return;
+            }
+            if (trimmed === '/pause' || trimmed === '/resume' || trimmed === '/cancel') {
+                sendControl(trimmed.slice(1));
+                return;
+            }
+            pendingStdin = line;
+            reasonCodes.add(LOCAL_JOBS_CONSOLE_REASON_CODES.STDIN_CONFIRMATION_REQUIRED);
+            stdout.write('[jobs-console] confirm stdin: type yes to send this line to the local process; anything else discards it.\n');
+        };
+        cleanupInput = () => {
+            readline.removeListener('line', onLine);
+            readline.close();
+        };
+        readline.on('line', onLine);
+        socket.on('connect', () => {
+            attached = true;
+            clearTimeout(timer);
+            reasonCodes.add(LOCAL_JOBS_CONSOLE_REASON_CODES.ATTACHED);
+            stdout.write(`[jobs-console] attached job=${parsed.jobId} serverHeldStream=false serverAccessToLocalhost=false controls=/pause,/resume,/cancel,/quit\n`);
+        });
+        socket.on('data', (chunk) => {
+            buffer += chunk.toString('utf8');
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? '';
+            for (const line of lines) {
+                const frame = parseServerFrame(line);
+                if (!frame)
+                    continue;
+                if (frame.type === 'stdout')
+                    stdout.write(decodeBase64Frame(frame.data) ?? Buffer.alloc(0));
+                else if (frame.type === 'stderr')
+                    stderr.write(decodeBase64Frame(frame.data) ?? Buffer.alloc(0));
+                else if (frame.type === 'control_ack') {
+                    reasonCodes.add(frame.reasonCode);
+                    stdout.write(`[jobs-console] control ${frame.action} ${frame.ok ? 'applied' : 'failed'} reason=${frame.reasonCode}\n`);
+                }
+                else if (frame.type === 'stdin_ack') {
+                    reasonCodes.add(frame.reasonCode);
+                    stdout.write(`[jobs-console] stdin ${frame.ok ? 'sent' : 'failed'} reason=${frame.reasonCode}\n`);
+                }
+                else if (frame.type === 'exit') {
+                    finish('attached', 0);
+                }
+            }
+        });
+        socket.on('error', () => {
+            if (attached || settled) {
+                reasonCodes.add(LOCAL_JOBS_CONSOLE_REASON_CODES.IPC_UNAVAILABLE);
+                finish('error', 1);
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            cleanupInput();
+            const result = publicConsoleResult('not-attached', 0, parsed.jobId, [LOCAL_JOBS_CONSOLE_REASON_CODES.NOT_ATTACHED]);
+            writeConsoleStatus(stdout, result, options.format);
+            resolvePromise(result);
+        });
+        socket.on('close', () => {
+            if (!settled && attached)
+                finish('attached', 0);
+        });
+    });
+}
+function canonicalJobId(value) {
+    const raw = value.replace(/^@/, '');
+    const match = raw.match(/^job-J(\d{3,})$/i);
+    return match ? `job-J${match[1]}` : raw;
+}
+function sanitizeSocketToken(value) {
+    return value.replace(/[^A-Za-z0-9._-]+/g, '-').slice(0, 80) || 'job';
+}
+function rawChunkFrame(type, chunk) {
+    return { type, data: Buffer.from(chunk).toString('base64'), encoding: 'base64' };
+}
+function parseClientFrame(line) {
+    const frame = parseJsonRecord(line);
+    if (!frame)
+        return undefined;
+    if (frame.type === 'stdin' && typeof frame.data === 'string' && frame.encoding === 'base64')
+        return frame;
+    if (frame.type === 'control' && (frame.action === 'pause' || frame.action === 'resume' || frame.action === 'cancel'))
+        return frame;
+    if (frame.type === 'close')
+        return { type: 'close' };
+    return undefined;
+}
+function parseServerFrame(line) {
+    const frame = parseJsonRecord(line);
+    if (!frame || typeof frame.type !== 'string')
+        return undefined;
+    return frame;
+}
+function parseJsonRecord(line) {
+    if (!line.trim())
+        return undefined;
+    try {
+        const parsed = JSON.parse(line);
+        return typeof parsed === 'object' && parsed !== null && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function decodeBase64Frame(value) {
+    try {
+        return Buffer.from(value, 'base64');
+    }
+    catch {
+        return undefined;
+    }
+}
+function signalForControl(action) {
+    if (action === 'pause')
+        return process.platform === 'win32' ? undefined : 'SIGSTOP';
+    if (action === 'resume')
+        return process.platform === 'win32' ? undefined : 'SIGCONT';
+    return 'SIGTERM';
+}
+function publicConsoleResult(status, exitCode, jobId, reasonCodes) {
+    return {
+        status,
+        exitCode,
+        ...(jobId ? { jobId } : {}),
+        reasonCodes: reasonCodes.length > 0 ? Array.from(new Set(reasonCodes)) : [LOCAL_JOBS_CONSOLE_REASON_CODES.OK],
+        serverHeldStream: false,
+        serverAccessToLocalhost: false,
+        publicSafe: true,
+    };
+}
+function writeConsoleStatus(stdout, result, format = 'plain') {
+    if (format === 'json') {
+        stdout.write(`${JSON.stringify({ type: 'jobs_console_status', ...result })}\n`);
+        return;
+    }
+    const job = result.jobId ? ` job=${result.jobId}` : '';
+    stdout.write(`[jobs-console] status=${result.status}${job} serverHeldStream=false serverAccessToLocalhost=false reasons=${result.reasonCodes.join(',')}\n`);
+}