workoffdesk 0.0.0-stage → 1.0.0

package/dist/server/agents/codex/items.js

@@ -0,0 +1,226 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : undefined);
+const str = (v) => (typeof v === 'string' ? v : '');
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : undefined);
+const arr = (v) => (Array.isArray(v) ? v : []);
+const SUMMARY_MAX = 200;
+const RESULT_MAX = 2000;
+const DIFF_LINES_MAX = 300;
+const DIFF_LINE_MAX = 400;
+const DETAIL_MAX = 4000;
+const clip = (s, max) => (s.length > max ? `${s.slice(0, max)}…` : s);
+const line1 = (s) => clip(s.split('\n')[0], SUMMARY_MAX);
+// What the user typed, as the chat shows it; a picture sent along is named by its path in the text already.
+const userText = (content) => arr(content)
+    .map((c) => (obj(c)?.type === 'text' ? str(obj(c)?.text) : ''))
+    .filter(Boolean)
+    .join('\n');
+// The command as Codex parsed it rather than the shell line that wraps it (`/bin/zsh -c '…'`).
+const commandOf = (i) => str(obj(arr(i.commandActions)[0])?.command) || str(i.command);
+function unifiedDiff(file, kind, text) {
+    const lines = text.replace(/\n$/, '').split('\n');
+    const hunks = [];
+    let added = 0;
+    let removed = 0;
+    let kept = 0;
+    let cut = false;
+    const push = (h, l) => {
+        if (l.startsWith('+'))
+            added++;
+        else if (l.startsWith('-'))
+            removed++;
+        if (kept >= DIFF_LINES_MAX)
+            return void (cut = true);
+        h.lines.push(clip(l, DIFF_LINE_MAX));
+        kept++;
+    };
+    if (!lines.some((l) => l.startsWith('@@'))) {
+        // A file made or removed whole comes as its content.
+        const sign = kind === 'delete' ? '-' : '+';
+        const h = { oldStart: kind === 'delete' ? 1 : 0, newStart: kind === 'delete' ? 0 : 1, lines: [] };
+        for (const l of text ? lines : [])
+            push(h, sign + l);
+        if (h.lines.length)
+            hunks.push(h);
+    }
+    else {
+        let h = null;
+        for (const l of lines) {
+            const at = /^@@ -(\d+)(?:,\d+)? \+(\d+)(?:,\d+)? @@/.exec(l);
+            if (at) {
+                h = { oldStart: Number(at[1]), newStart: Number(at[2]), lines: [] };
+                hunks.push(h);
+            }
+            else if (h && /^[ +-]/.test(l))
+                push(h, l);
+        }
+    }
+    return { file, added, removed, ...(kind === 'add' && { created: true }), ...(cut ? { cut: true } : {}), hunks };
+}
+const failedOrStopped = (status) => ({ error: status === 'failed', ...(status === 'declined' && { stopped: true }) });
+// What one completed item adds to the chat; nothing for what the chat does not show (reasoning).
+export function entriesOf(item, at) {
+    const i = obj(item);
+    const id = str(i?.id);
+    if (!i || !id)
+        return [];
+    const stamp = at ? { at } : {};
+    switch (i.type) {
+        case 'userMessage': {
+            const text = userText(i.content);
+            const clientId = str(i.clientId);
+            return text ? [{ id, item: { k: 'user', text, ...stamp }, ...(clientId && { clientId }) }] : [];
+        }
+        case 'agentMessage':
+            return str(i.text) ? [{ id, item: { k: 'text', text: str(i.text), ...stamp } }] : [];
+        case 'plan':
+            return str(i.text) ? [{ id, item: { k: 'text', text: str(i.text), ...stamp } }] : [];
+        case 'commandExecution': {
+            const status = str(i.status);
+            const exit = num(i.exitCode);
+            return [
+                { id, item: { k: 'tool', id, name: 'Bash', summary: line1(commandOf(i)), ...stamp } },
+                { id: `${id}#r`, item: { k: 'result', id, text: clip(str(i.aggregatedOutput), RESULT_MAX), ...failedOrStopped(status), ...(exit !== undefined && exit !== 0 && { error: true }) } },
+            ];
+        }
+        case 'fileChange': {
+            const status = str(i.status);
+            return arr(i.changes).flatMap((c, n) => {
+                const change = obj(c);
+                const path = str(change?.path);
+                if (!path)
+                    return [];
+                const kind = str(obj(change?.kind)?.type);
+                const cid = `${id}:${n}`;
+                return [
+                    { id: cid, item: { k: 'tool', id: cid, name: kind === 'add' ? 'Write' : 'Edit', summary: line1(path), ...stamp } },
+                    { id: `${cid}#r`, item: { k: 'result', id: cid, text: '', ...failedOrStopped(status), diff: unifiedDiff(path, kind, str(change?.diff)) } },
+                ];
+            });
+        }
+        case 'mcpToolCall':
+        case 'dynamicToolCall': {
+            const name = [str(i.server) || str(i.namespace), str(i.tool)].filter(Boolean).join('.');
+            const args = obj(i.arguments) ?? {};
+            const summary = line1(Object.values(args).map(str).find(Boolean) ?? '');
+            const error = str(obj(i.error)?.message);
+            const text = error || arr(obj(i.result)?.content ?? i.contentItems).map((c) => str(obj(c)?.text)).filter(Boolean).join('\n');
+            return [
+                { id, item: { k: 'tool', id, name: name || 'tool', summary, ...stamp } },
+                { id: `${id}#r`, item: { k: 'result', id, text: clip(text, RESULT_MAX), error: !!error || str(i.status) === 'failed' || i.success === false } },
+            ];
+        }
+        case 'webSearch':
+            return [{ id, item: { k: 'tool', id, name: 'WebSearch', summary: line1(str(i.query)), ...stamp } }];
+        case 'imageView':
+            return [{ id, item: { k: 'tool', id, name: 'Read', summary: line1(str(i.path)), ...stamp } }];
+        case 'contextCompaction':
+            return [{ id, item: { k: 'note', event: { e: 'compacted' } } }];
+        default:
+            return [];
+    }
+}
+// A turn that did not end by itself, as the line the chat puts after it.
+export function turnNote(turn) {
+    const t = obj(turn);
+    const id = str(t?.id);
+    if (!t || !id)
+        return null;
+    if (t.status === 'interrupted')
+        return { id: `${id}#end`, item: { k: 'note', event: { e: 'interrupted' } } };
+    if (t.status === 'failed') {
+        const detail = str(obj(t.error)?.message);
+        return { id: `${id}#end`, item: { k: 'note', event: { e: 'failed' }, ...(detail && { detail }) } };
+    }
+    return null;
+}
+export const COMMAND_APPROVAL = 'item/commandExecution/requestApproval';
+export const FILE_APPROVAL = 'item/fileChange/requestApproval';
+export const isApproval = (method) => method === COMMAND_APPROVAL || method === FILE_APPROVAL;
+// The decision that allows from now on what the request offers to, if it offers that.
+function amendmentOf(params) {
+    for (const d of arr(params.availableDecisions)) {
+        const a = obj(obj(d)?.acceptWithExecpolicyAmendment);
+        const prefix = arr(a?.execpolicy_amendment).map(str);
+        if (prefix.length && prefix.every(Boolean))
+            return { acceptWithExecpolicyAmendment: { execpolicy_amendment: prefix } };
+    }
+    return null;
+}
+const offered = (params, decision) => {
+    const all = arr(params.availableDecisions);
+    return !all.length || all.includes(decision);
+};
+// An approval Codex asks for, as the phone's permission card. fileItem: the file change it is for, as it
+// started, which names the files the request itself does not.
+export function askOf(askId, method, params, fileItem) {
+    const reason = str(params.reason);
+    if (method === COMMAND_APPROVAL) {
+        const command = commandOf(params);
+        const amendment = amendmentOf(params);
+        const detail = [command, reason, str(params.cwd)].filter(Boolean).join('\n\n');
+        return {
+            id: askId,
+            kind: 'permission',
+            tool: 'Bash',
+            title: line1(command || reason),
+            detail: clip(detail, DETAIL_MAX),
+            always: amendment ? { rules: [amendment.acceptWithExecpolicyAmendment.execpolicy_amendment.join(' ')], dirs: [], mode: null } : null,
+        };
+    }
+    const changes = arr(fileItem?.changes).map(obj);
+    const paths = changes.map((c) => str(c?.path)).filter(Boolean);
+    const diffs = changes.map((c) => str(c?.diff)).filter(Boolean).join('\n');
+    return {
+        id: askId,
+        kind: 'permission',
+        tool: 'Edit',
+        title: line1(paths.join(', ') || str(params.grantRoot) || reason),
+        detail: clip([reason, diffs].filter(Boolean).join('\n\n'), DETAIL_MAX),
+        always: offered(params, 'acceptForSession') ? { rules: [], dirs: [], mode: 'acceptEdits' } : null,
+    };
+}
+// The reply to an approval. No is the Mac's No: the turn stops.
+export function decisionOf(method, params, answer) {
+    if (!answer.allow)
+        return { decision: offered(params, 'cancel') ? 'cancel' : 'decline' };
+    if (!answer.always)
+        return { decision: 'accept' };
+    if (method === COMMAND_APPROVAL)
+        return { decision: amendmentOf(params) ?? 'acceptForSession' };
+    return { decision: 'acceptForSession' };
+}
+// What the usage pill shows, from the thread's last token count and the plan's limits.
+export function usageOf(o) {
+    const u = {};
+    if (o.model)
+        u.model = o.model.slice(0, 80);
+    if (o.effort)
+        u.effort = o.effort.slice(0, 80);
+    const tokens = obj(o.tokenUsage);
+    const window = num(tokens?.modelContextWindow);
+    const last = num(obj(tokens?.last)?.totalTokens);
+    if (window && last !== undefined)
+        u.context = Math.min(100, Math.round((last / window) * 100));
+    const limits = obj(o.rateLimits);
+    const limit = (w) => {
+        const used = num(obj(w)?.usedPercent);
+        const resetsAt = num(obj(w)?.resetsAt);
+        return used === undefined ? undefined : { used: Math.min(100, Math.max(0, used)), ...(resetsAt !== undefined && { resetsAt }) };
+    };
+    const fiveHour = limit(limits?.primary);
+    const sevenDay = limit(limits?.secondary);
+    if (fiveHour)
+        u.fiveHour = fiveHour;
+    if (sevenDay)
+        u.sevenDay = sevenDay;
+    return Object.keys(u).length ? u : null;
+}
+// A picture sent from the phone travels as its path in the text (libs/client/src/chat/images.ts); Codex is also
+// given it as an image.
+const UPLOADED_PICTURE = /~?\/[^\s"]*\/uploads\/\d{4}-\d{2}-\d{2}-\d{6}-[0-9a-f]{6}\.(?:png|jpg|jpeg|gif|webp)/g;
+export function inputOf(text) {
+    const pictures = [...new Set(text.match(UPLOADED_PICTURE) ?? [])].map((p) => (p.startsWith('~/') ? join(homedir(), p.slice(2)) : p));
+    return [{ type: 'text', text, text_elements: [] }, ...pictures.map((path) => ({ type: 'localImage', path }))];
+}

package/dist/server/agents/codex/notifications.js

@@ -0,0 +1,192 @@
+import { realpathSync } from 'node:fs';
+import { askOf, entriesOf, isApproval, turnNote, usageOf } from './items.js';
+const obj = (v) => (v && typeof v === 'object' && !Array.isArray(v) ? v : undefined);
+const str = (v) => (typeof v === 'string' ? v : '');
+// How often the reply being written is put in the journal while deltas come.
+const LIVE_MS = 200;
+const realDir = (p) => {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        return p;
+    }
+};
+// What the app server tells of the threads the agent follows, and what it asks: turned into each session's
+// status, chat, asks and usage.
+export class CodexNotifications {
+    host;
+    threads;
+    agent;
+    rateLimits = null;
+    constructor(host, threads, agent) {
+        this.host = host;
+        this.threads = threads;
+        this.agent = agent;
+    }
+    notified({ method, params }) {
+        if (method === 'account/rateLimits/updated') {
+            this.rateLimits = params.rateLimits;
+            for (const t of this.threads.values())
+                this.usage(t);
+            return;
+        }
+        if (method === 'thread/started')
+            return this.started(obj(params.thread));
+        const t = this.threads.get(str(params.threadId));
+        if (!t)
+            return;
+        switch (method) {
+            case 'thread/status/changed':
+                this.statusIs(t, obj(params.status));
+                if (!t.joined)
+                    void this.agent.join(t);
+                return;
+            case 'thread/closed':
+                t.joined = false;
+                return;
+            case 'thread/name/updated':
+                this.nameIs(t, params.threadName);
+                return;
+            case 'turn/completed': {
+                const note = turnNote(params.turn);
+                if (note)
+                    this.put(t, [note]);
+                if (t.asks.size) {
+                    t.asks.clear();
+                    this.host.asksChanged(t.session);
+                }
+                return;
+            }
+            case 'item/started': {
+                const item = obj(params.item);
+                if (item?.type === 'fileChange')
+                    t.files.set(str(item.id), item);
+                if (item?.type === 'contextCompaction')
+                    this.compacting(t, true);
+                return;
+            }
+            case 'item/completed': {
+                const item = obj(params.item);
+                const at = typeof params.completedAtMs === 'number' ? new Date(params.completedAtMs).toISOString() : undefined;
+                this.put(t, entriesOf(item, at));
+                if (item?.type === 'agentMessage') {
+                    t.said = str(item.text) || t.said;
+                    this.liveDone(t, str(item.id));
+                }
+                if (item?.type === 'fileChange')
+                    t.files.delete(str(item.id));
+                if (item?.type === 'contextCompaction')
+                    this.compacting(t, false);
+                return;
+            }
+            case 'item/agentMessage/delta':
+                t.live.set(str(params.itemId), (t.live.get(str(params.itemId)) ?? '') + str(params.delta));
+                t.liveTimer ??= setTimeout(() => this.liveNow(t), LIVE_MS);
+                return;
+            case 'thread/tokenUsage/updated':
+                t.tokenUsage = params.tokenUsage;
+                this.usage(t);
+                return;
+            case 'thread/settings/updated': {
+                const s = obj(params.threadSettings);
+                t.model = str(s?.model) || t.model;
+                t.effort = str(s?.effort) || t.effort;
+                this.usage(t);
+                return;
+            }
+            case 'serverRequest/resolved': {
+                const gone = [...t.asks.entries()].find(([, a]) => a.requestId === params.requestId);
+                if (!gone)
+                    return;
+                t.asks.delete(gone[0]);
+                this.host.asksChanged(t.session);
+                return;
+            }
+        }
+    }
+    // An approval is held for the phone; the TUI has it too and either may answer. Anything else Codex asks is
+    // left to the TUI.
+    requested({ id, method, params }) {
+        const t = this.threads.get(str(params.threadId));
+        if (!t || !isApproval(method))
+            return;
+        const askId = `codex-${String(id)}`;
+        const ask = askOf(askId, method, params, t.files.get(str(params.itemId)));
+        t.asks.set(askId, { requestId: id, method, params, ask });
+        this.host.asksChanged(t.session);
+        if (t.status === 'waiting')
+            this.host.moved(t.session, 'waiting', ask.title);
+    }
+    started(thread) {
+        const threadId = str(thread?.id);
+        if (!thread || !threadId || thread.ephemeral === true || thread.parentThreadId || this.threads.has(threadId))
+            return;
+        const sessions = this.host.sessions();
+        if (sessions.some((s) => s.threadId === threadId))
+            return;
+        // Only the sessions' TUIs run on this app server: a thread started in a folder is the oldest session there
+        // with none yet. Its TUI may have asked something first (trust this folder?) for any time.
+        const cwd = realDir(str(thread.cwd));
+        const [owner] = sessions
+            .filter((s) => !s.threadId && !this.agent.following(s.id) && realDir(s.cwd) === cwd)
+            .sort((a, b) => a.createdAt - b.createdAt);
+        if (!owner)
+            return;
+        this.host.setThread(owner.id, threadId);
+        const t = this.agent.track(owner.id, threadId);
+        // Joined only once its first turn writes it; what it runs on is known now.
+        this.ranOn(t, thread);
+        this.host.moved(owner.id, t.status, '');
+    }
+    nameIs(t, name) {
+        if (typeof name === 'string' && name.trim())
+            this.host.named(t.session, name);
+    }
+    statusIs(t, status) {
+        const type = str(status?.type);
+        const flags = Array.isArray(status?.activeFlags) ? status.activeFlags : [];
+        if (type === 'active')
+            t.status = flags.length ? 'waiting' : 'working';
+        else if (type === 'idle' || type === 'systemError')
+            t.status = 'idle';
+        else
+            return;
+        this.show(t);
+    }
+    compacting(t, on) {
+        t.compacting = on;
+        this.show(t);
+    }
+    show(t) {
+        const status = t.compacting ? 'compacting' : t.status;
+        const said = status === 'waiting' ? ([...t.asks.values()].at(-1)?.ask.title ?? '') : t.said;
+        this.host.moved(t.session, status, said);
+    }
+    // The model and effort a thread runs on, as the thread itself says.
+    ranOn(t, thread) {
+        t.model = str(thread?.model) || t.model;
+        t.effort = str(thread?.reasoningEffort) || t.effort;
+        this.usage(t);
+    }
+    usage(t) {
+        this.host.setUsage(t.session, usageOf({ tokenUsage: t.tokenUsage, rateLimits: this.rateLimits, model: t.model, effort: t.effort }));
+    }
+    put(t, entries) {
+        if (entries.length)
+            this.host.journal.putAgentItems(t.session, t.threadId, entries);
+    }
+    liveNow(t) {
+        t.liveTimer = null;
+        if (this.threads.get(t.threadId) !== t)
+            return;
+        this.host.journal.live(t.session, [...t.live.values()].at(-1) || null);
+    }
+    liveDone(t, itemId) {
+        t.live.delete(itemId);
+        if (t.liveTimer)
+            clearTimeout(t.liveTimer);
+        t.liveTimer = null;
+        this.host.journal.live(t.session, [...t.live.values()].at(-1) || null);
+    }
+}

package/dist/server/agents/codex/rpc.js

@@ -0,0 +1,121 @@
+import { realpathSync } from 'node:fs';
+import WebSocket from 'ws';
+import { VERSION } from '../../system/version.js';
+export class RpcError extends Error {
+    code;
+    // Codes of this client's own: the connection closed, or no answer came in time.
+    static CLOSED = -1;
+    static TIMEOUT = -2;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+const REQUEST_MS = 15_000;
+const CONNECT_MS = 5_000;
+// A client of Codex's app server: JSON-RPC 2.0 messages, one per WebSocket frame, over its unix socket.
+export class CodexRpc {
+    ws;
+    seq = 0;
+    pending = new Map();
+    notified = new Set();
+    requested = new Set();
+    closed = new Set();
+    constructor(ws) {
+        this.ws = ws;
+        ws.on('message', (data) => this.receive(String(data)));
+        ws.on('close', () => {
+            for (const p of this.pending.values()) {
+                clearTimeout(p.timer);
+                p.reject(new RpcError(RpcError.CLOSED, 'codex app server closed'));
+            }
+            this.pending.clear();
+            for (const cb of this.closed)
+                cb();
+        });
+        ws.on('error', () => { });
+    }
+    // Connected and introduced; throws when nothing listens on the socket.
+    static async connect(sock) {
+        // Codex keeps a socket whose path is too long behind a symlink, which a unix socket address cannot follow.
+        const path = realpathSync(sock);
+        const ws = new WebSocket(`ws+unix://${path}:/`, { handshakeTimeout: CONNECT_MS });
+        await new Promise((resolve, reject) => {
+            ws.once('open', () => resolve());
+            ws.once('error', reject);
+        });
+        const rpc = new CodexRpc(ws);
+        await rpc.request('initialize', { clientInfo: { name: 'workoffdesk', title: 'WorkOffDesk', version: VERSION }, capabilities: { experimentalApi: true } });
+        rpc.send({ method: 'initialized' });
+        return rpc;
+    }
+    get open() {
+        return this.ws.readyState === WebSocket.OPEN;
+    }
+    request(method, params, timeoutMs = REQUEST_MS) {
+        const id = `wod-${++this.seq}`;
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new RpcError(RpcError.TIMEOUT, `${method} did not answer in time`));
+            }, timeoutMs);
+            this.pending.set(id, { resolve: resolve, reject, timer });
+            if (!this.send({ id, method, params })) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(new RpcError(RpcError.CLOSED, 'codex app server closed'));
+            }
+        });
+    }
+    respond(id, result) {
+        return this.send({ id, result });
+    }
+    onNotification(cb) {
+        this.notified.add(cb);
+    }
+    onRequest(cb) {
+        this.requested.add(cb);
+    }
+    onClose(cb) {
+        this.closed.add(cb);
+    }
+    close() {
+        this.ws.close();
+    }
+    send(msg) {
+        if (!this.open)
+            return false;
+        this.ws.send(JSON.stringify(msg));
+        return true;
+    }
+    receive(text) {
+        let msg;
+        try {
+            msg = JSON.parse(text);
+        }
+        catch {
+            return;
+        }
+        const params = (msg.params && typeof msg.params === 'object' ? msg.params : {});
+        if (typeof msg.method === 'string') {
+            if (msg.id === undefined)
+                for (const cb of this.notified)
+                    cb({ method: msg.method, params });
+            else
+                for (const cb of this.requested)
+                    cb({ id: msg.id, method: msg.method, params });
+            return;
+        }
+        if (msg.id === undefined)
+            return;
+        const p = this.pending.get(msg.id);
+        if (!p)
+            return;
+        this.pending.delete(msg.id);
+        clearTimeout(p.timer);
+        if (msg.error)
+            p.reject(new RpcError(Number(msg.error.code ?? 0), String(msg.error.message ?? 'error')));
+        else
+            p.resolve(msg.result ?? {});
+    }
+}

package/dist/server/agents/codex/screen.js

@@ -0,0 +1,5 @@
+import { parseChoices } from '../claude/screen/choices.js';
+// What Codex's TUI asks before its thread starts (trust this folder?), read off the screen as Claude Code's
+// choices are: the same numbered list, its current option marked › rather than ❯. Only before: once a thread
+// runs, the messages sent are drawn after a › too, and what Codex asks comes from its app server.
+export const codexChoices = (screen) => parseChoices(screen.replace(/›/g, '❯'));