workoffdesk 0.0.0-stage → 1.0.0

package/dist/server/agents/claude/screen/compacting.js

@@ -0,0 +1,20 @@
+// Whether Claude Code is compacting its conversation, read off the screen: its spinner, the line nearest above
+// the prompt, says so (a tip may sit under it). The conversation is further up and indented, so words in it
+// are not taken for the spinner.
+const PROMPT_TOP = /^─{10,}/;
+const PROMPT_LINE = /^[❯!]/;
+const TIP = /^\s*⎿/;
+// Any glyph but the ⏺ that starts each of Claude's replies, then what the spinner says.
+const SPINNER = /^[^\s⏺]\s+(Compacting conversation|Running (Pre|Post)Compact hooks)/;
+export function isCompacting(screen) {
+    const lines = screen.split('\n').map((l) => l.trimEnd());
+    let top = -1;
+    for (let i = lines.length - 2; i >= 0 && top < 0; i--)
+        if (PROMPT_TOP.test(lines[i]) && PROMPT_LINE.test(lines[i + 1]))
+            top = i;
+    const above = lines.slice(0, Math.max(top, 0)).filter((l) => l.trim());
+    let spinner = above.pop();
+    if (spinner !== undefined && TIP.test(spinner))
+        spinner = above.pop();
+    return spinner !== undefined && SPINNER.test(spinner);
+}

package/dist/server/agents/claude/screen/live.js

@@ -0,0 +1,63 @@
+// What Claude is writing now, read off the screen: the transcript gets a reply only once it is whole, while
+// the screen shows it line by line. Its text is the last block that starts with ⏺ and goes on in lines
+// indented two spaces, above the rule over the prompt and below the last message the user sent, so the reply
+// to an earlier message is never taken for this one's. A block that is a tool at work, or reads and searches,
+// is not a reply.
+const BLOCK_START = /^⏺ /;
+const GOES_ON = /^ {2}/;
+const TOOL = /^⏺ [\w.:-]+\(/;
+// Reads and searches, drawn as one line that opens with ctrl+o; while they run its ⏺ blinks to a space.
+const CALLS = /^(?:⏺| ) \S.*\(ctrl\+o to expand\)$/;
+const TOOL_RESULT = '⎿';
+// A message the user sent, and the prompt they type at, which sits between two rules.
+const SENT = /^❯(?:[\u00a0 ]|$)/;
+const RULE = /^─{8,}$/;
+const INDENT = 2;
+// Lines that start a block of their own (list item, heading, quote, fence, table) are never a wrapped tail.
+const OWN_LINE = /^(?:[-*+] |\d+[.)] |#|>|```|\|)/;
+const WIDE = /[\u1100-\u115F\u2E80-\uA4CF\uAC00-\uD7A3\uF900-\uFAFF\uFE30-\uFE4F\uFF00-\uFF60\uFFE0-\uFFE6\u{1F300}-\u{1FAFF}\u{20000}-\u{3FFFD}]/u;
+function cells(s) {
+    let n = 0;
+    for (const ch of s)
+        n += WIDE.test(ch) ? 2 : 1;
+    return n;
+}
+// Claude Code breaks its own lines to fit the terminal, which -J cannot undo. A line was broken by the
+// terminal, not by Claude, when the next line's first word would not have fitted after it.
+function unwrap(lines, width) {
+    const out = [];
+    for (const line of lines) {
+        const prev = out[out.length - 1];
+        const first = /^\S+/.exec(line)?.[0] ?? '';
+        const wide = WIDE.test(first[0] ?? '');
+        const head = wide ? first[0] : first;
+        const fits = prev !== undefined && cells(prev) + (wide ? 0 : 1) + cells(head) <= width;
+        if (prev && line && !OWN_LINE.test(line) && !fits) {
+            out[out.length - 1] = prev + (wide || WIDE.test(prev.slice(-1)) ? '' : ' ') + line;
+        }
+        else
+            out.push(line);
+    }
+    return out;
+}
+// `screen` is a capture with wrapped lines joined (capture-pane -J); `cols` is the width it was drawn at.
+export function liveText(screen, cols) {
+    const lines = screen.split('\n').map((l) => l.trimEnd());
+    let prompt = lines.length;
+    for (let i = lines.length - 1; i > 0 && prompt === lines.length; i--)
+        if (SENT.test(lines[i]) && RULE.test(lines[i - 1]))
+            prompt = i - 1;
+    let start = -1;
+    for (let i = prompt - 1; i >= 0 && start < 0 && !SENT.test(lines[i]); i--)
+        if (BLOCK_START.test(lines[i]) || CALLS.test(lines[i]))
+            start = i;
+    if (start < 0 || TOOL.test(lines[start]) || CALLS.test(lines[start]))
+        return null;
+    const block = [lines[start].slice(INDENT)];
+    for (let i = start + 1; i < lines.length && (!lines[i] || GOES_ON.test(lines[i])); i++)
+        block.push(lines[i].slice(INDENT));
+    if (block.some((l) => l.includes(TOOL_RESULT)))
+        return null;
+    const text = unwrap(block, cols - INDENT).join('\n').trim();
+    return text || null;
+}

package/dist/server/agents/claude/screen/panel.js

@@ -0,0 +1,140 @@
+// A dialog a slash command opened over Claude Code's prompt (/usage, /config, /model, …), read off the
+// screen. While one is up the prompt is gone, so typing goes into the dialog instead of to Claude.
+// Its top edge is a row of ▔ (other text may share that row) or a plain rule; taller than the screen, that
+// edge has scrolled into `above`, the scrollback just above the screen. Its key hint is the last block.
+import { parseChoices } from './choices.js';
+const RULE = /^─{10,}$/;
+// The prompt: a rule, maybe with a label on it, over the line being typed (❯, or ! in shell mode).
+const PROMPT_TOP = /^─{10,}/;
+const PROMPT_LINE = /^[❯!]/;
+const EDGE = '▔';
+// The settings dialog /config, /usage and /status open, whichever tab it is on.
+const SETTINGS_TABS = /^Settings\s{2,}Status\s{2,}Config\b/;
+const TABS_WRAPPED = /^\s*(Status|Config|Usage|Stats)(\s{2,}(Status|Config|Usage|Stats))*\s*$/;
+const SEARCH_BOX = /^[╭│╰]/;
+const HINT = /\bEsc to \w+|\bEnter to \w+/;
+const TITLE_MAX = 40;
+// The dialogs known by name. The settings dialog says which tab is up only by what it holds.
+const HEADINGS = { 'Select model': 'Model', Effort: 'Effort' };
+const USAGE_TAB = /^\s*Total cost:/m;
+const CONFIG_TAB = /to search\b|Esc to clear/;
+export function parsePanel(screen, above = '') {
+    let shown = screen.split('\n').map((l) => l.trimEnd());
+    // A dialog opened while Claude works stands above the prompt rather than in its place: what is above
+    // the prompt is a dialog only when its key hint is the last thing there.
+    const prompt = shown.findIndex((l, i) => i > 0 && PROMPT_TOP.test(shown[i - 1].trim()) && PROMPT_LINE.test(l));
+    if (prompt > 0) {
+        shown = shown.slice(0, prompt - 1);
+        while (shown.length && !shown[shown.length - 1])
+            shown.pop();
+        if (!HINT.test(shown.slice(shown.lastIndexOf('') + 1).join(' ')))
+            return null;
+    }
+    const btw = btwOf(shown);
+    if (btw)
+        return btw;
+    // A question Claude asks is for the choices; a dialog with options in it, whose edge is ▔, is not.
+    if (!shown.some((l) => l.endsWith(EDGE)) && parseChoices(screen))
+        return null;
+    const lines = above ? [...above.split('\n').map((l) => l.trimEnd()), ...shown] : shown;
+    let top = -1;
+    for (let i = lines.length - 1; i >= 0 && top < 0; i--)
+        if (lines[i].endsWith(EDGE) || RULE.test(lines[i].trim()))
+            top = i;
+    if (top < 0)
+        return null;
+    let rest = lines.slice(top + 1);
+    const indent = Math.min(...rest.filter((l) => l.trim()).map((l) => l.length - l.trimStart().length));
+    rest = rest.map((l) => l.slice(indent)).filter((l) => !SEARCH_BOX.test(l));
+    // The key hint: the last block of lines, wrapped across them.
+    while (rest.length && !rest[rest.length - 1])
+        rest.pop();
+    let hint = '';
+    const blank = rest.lastIndexOf('');
+    const last = rest.slice(blank + 1).join(' ');
+    if (HINT.test(last)) {
+        hint = last.replace(/\s+/g, ' ').trim();
+        rest = rest.slice(0, Math.max(blank, 0));
+    }
+    const first = rest.findIndex((l) => l.trim());
+    if (first < 0)
+        return null;
+    const heading = rest[first].trim();
+    let from = first + 1;
+    // The settings tabs wrapped onto a second line on a narrow screen.
+    if (SETTINGS_TABS.test(heading) && TABS_WRAPPED.test(rest[from] ?? ''))
+        from++;
+    const body = rest
+        .slice(from)
+        .join('\n')
+        .replace(/\n{3,}/g, '\n\n')
+        .trim();
+    if (SETTINGS_TABS.test(heading))
+        return usageOr({ title: CONFIG_TAB.test(hint) ? 'Settings' : '', body, hint });
+    const title = heading ? (HEADINGS[heading] ?? heading.slice(0, TITLE_MAX)) : '';
+    const effort = heading === 'Effort' ? effortOf(rest.slice(from)) : null;
+    return effort ? { title, body, hint, effort } : usageOr({ title, body, hint });
+}
+// A /btw answer has no edge: the questions asked so far, each a line of `/btw …`, then the answer to the
+// last, then its key hint, which offers to fork it.
+const BTW_ASKED = /^\s*\/btw\s/;
+const BTW_HINT = /\bto fork\b.*\bEsc to close\b/;
+function btwOf(shown) {
+    const lines = [...shown];
+    while (lines.length && !lines[lines.length - 1])
+        lines.pop();
+    const gap = lines.lastIndexOf('');
+    const hint = lines
+        .slice(gap + 1)
+        .join(' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (gap < 0 || !BTW_HINT.test(hint))
+        return null;
+    const asked = lines.slice(0, gap).findLastIndex((l) => BTW_ASKED.test(l));
+    if (asked < 0)
+        return null;
+    // The question runs on until the blank line under it, when it is too long for one.
+    const below = lines.indexOf('', asked);
+    const question = lines
+        .slice(asked, below)
+        .join(' ')
+        .replace(/\s+/g, ' ')
+        .trim()
+        .replace(/^\/btw\s+/, '');
+    const answer = lines.slice(below + 1, gap);
+    const indent = Math.min(...answer.filter((l) => l.trim()).map((l) => l.length - l.trimStart().length));
+    const body = answer
+        .map((l) => l.slice(Number.isFinite(indent) ? indent : 0))
+        .join('\n')
+        .trim();
+    return { title: 'Btw', body, hint, btw: { question } };
+}
+// The slider's marker (▲) on one line, the levels named under it; the level is the one whose name is
+// centred nearest the marker.
+const MARKER = '▲';
+const LEVELS_END = /\s{3,}Tab to toggle.*$/;
+function effortOf(lines) {
+    const marked = lines.findIndex((l) => l.includes(MARKER));
+    const named = lines[marked + 1];
+    if (marked < 0 || !named)
+        return null;
+    const mark = lines[marked].indexOf(MARKER);
+    const words = [...named.replace(LEVELS_END, '').matchAll(/\S+/g)];
+    if (words.length < 2)
+        return null;
+    const off = (w) => Math.abs(w.index + w[0].length / 2 - mark);
+    const at = words.reduce((best, w, i) => (off(w) < off(words[best]) ? i : best), 0);
+    return { levels: words.map((w) => w[0]), at };
+}
+function usageOr(p) {
+    const { body, hint } = p;
+    return USAGE_TAB.test(body) ? { title: 'Usage', body, hint, usage: { session: used(body, 'Current session'), week: used(body, 'Current week') } } : p;
+}
+// The first percentage below a line of the plan. The session's line comes above the week's, so when its
+// own percentage is off the screen, so is everything after it.
+function used(body, line) {
+    const at = body.indexOf(line);
+    const m = at < 0 ? null : /(\d+)% used/.exec(body.slice(at));
+    return m ? Number(m[1]) : null;
+}

package/dist/server/agents/claude/screen/prompt.js

@@ -0,0 +1,23 @@
+// What Claude Code shows at its prompt besides what is typed there.
+// After Claude answers it may offer what the user is likely to say next, dimmed at the empty prompt; what
+// is typed there is not dimmed.
+// eslint-disable-next-line no-control-regex -- the dimming is an escape sequence
+const SUGGESTION = new RegExp('❯[\\u00a0 ]\\x1b\\[2m([^\\x1b\\n]+)\\x1b\\[0m\\s*$');
+export function suggestionOn(styled) {
+    const lines = styled.replace(/\n+$/, '').split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+        if (!lines[i].includes('❯'))
+            continue;
+        const m = SUGGESTION.exec(lines[i]);
+        const text = m?.[1].trim();
+        // The hint on a fresh prompt is an example, not something to send.
+        return text && !/^Try "/.test(text) ? text : null;
+    }
+    return null;
+}
+// The permission mode, from the line under the prompt: "bypass permissions", "accept edits", "plan mode",
+// "auto mode"; null in the default mode, which shows none.
+const MODE = /(?:⏵⏵|⏸)\s+([a-z][a-z ]*?) on\b/;
+export function modeOn(screen) {
+    return MODE.exec(screen)?.[1] ?? null;
+}

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

@@ -0,0 +1,79 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+import { keysToChoose, keysToTick, parseChoices } from './choices.js';
+import { isCompacting } from './compacting.js';
+import { liveText } from './live.js';
+import { parsePanel } from './panel.js';
+import { modeOn, suggestionOn } from './prompt.js';
+// How far above the screen to look for the top edge of a dialog taller than it.
+const PANEL_ABOVE = 200;
+// How much of a plan file is sent to be read on the phone.
+const PLAN_MAX = 20_000;
+// Claude Code's TUI in a tmux session, as read off its screen and answered by keys. Sessions are tmux
+// session names.
+export class ClaudeScreen {
+    tmux;
+    cols;
+    constructor(tmux, 
+    // The width Claude's lines are taken to wrap at when the window's own cannot be read.
+    cols) {
+        this.tmux = tmux;
+        this.cols = cols;
+    }
+    // working: Claude is at work, so the text it is writing is read too. compacting: its spinner shows.
+    async read(name, working) {
+        const [{ screen, above }, styled, joined, cols] = await Promise.all([
+            this.tmux.screenAndAbove(name, PANEL_ABOVE),
+            this.tmux.screenStyled(name).catch(() => ''),
+            working ? this.tmux.screenJoined(name).catch(() => '') : Promise.resolve(''),
+            working ? this.tmux.windowSize(name).then((s) => s.cols, () => this.cols) : Promise.resolve(this.cols),
+        ]);
+        const choices = withPlan(parseChoices(screen));
+        const panel = parsePanel(screen, above);
+        const live = working && !choices && !panel ? liveText(joined, cols) : null;
+        return { screen: { choices, panel, suggestion: suggestionOn(styled), mode: modeOn(screen), live }, compacting: isCompacting(screen) };
+    }
+    async choices(name, parse = parseChoices) {
+        return parse(await this.tmux.screen(name));
+    }
+    // Takes option `index` if it is still `label` on screen; false when the screen has moved on. parse: how
+    // the screen's choices are read, for a TUI other than Claude Code's drawn the same way. text: an answer of
+    // one's own, for the option that is a field for one, typed into it and taken.
+    async choose(name, index, label, parse = parseChoices, text) {
+        const c = await this.choices(name, parse);
+        if (!c || c.options[index]?.label !== label)
+            return false;
+        if (text !== undefined && !c.options[index].typed)
+            return false;
+        await this.tmux.leaveCopyMode(name);
+        await this.tmux.sendRaw(name, keysToChoose(c, index));
+        if (text !== undefined)
+            await this.tmux.paste(name, text);
+        return true;
+    }
+    // Sends a question that takes several answers with the options at `ticked` ticked, if it is still the
+    // one whose options were `labels`.
+    async tick(name, ticked, labels) {
+        const c = await this.choices(name);
+        if (!c?.submit || c.options.length !== labels.length || c.options.some((o, i) => o.label !== labels[i]))
+            return false;
+        if (ticked.some((i) => i >= c.options.length || c.options[i].typed))
+            return false;
+        await this.tmux.leaveCopyMode(name);
+        await this.tmux.sendRaw(name, keysToTick(c, ticked));
+        return true;
+    }
+}
+// A choice to go ahead with a plan, with the plan it names read from Claude Code's plans folder; the name
+// is a bare file name, so nothing outside that folder is read.
+function withPlan(c) {
+    if (!c?.planFile)
+        return c;
+    try {
+        return { ...c, plan: readFileSync(join(homedir(), '.claude', 'plans', basename(c.planFile)), 'utf8').slice(0, PLAN_MAX) };
+    }
+    catch {
+        return c;
+    }
+}

package/dist/server/agents/claude/terminals.js

@@ -0,0 +1,110 @@
+import { execFile } from 'node:child_process';
+import { open } from 'node:fs/promises';
+export const busiest = (claudes) => claudes.some((c) => c.status === 'waiting') ? 'waiting' : claudes.some((c) => c.status === 'busy') ? 'busy' : 'idle';
+const LIST_MS = 5_000;
+// How long a Claude told to stop is given to write the rest of its transcript and go: it took under a second.
+const STOP_MS = 10_000;
+const STOP_LOOK_MS = 100;
+const STATUSES = new Set(['idle', 'busy', 'waiting']);
+const run = (bin, args, env) => new Promise((resolve, reject) => execFile(bin, args, { timeout: LIST_MS, maxBuffer: 16 * 1024 * 1024, env }, (err, stdout) => (err ? reject(err) : resolve(String(stdout)))));
+// Asked for again while a listing runs, the one running answers.
+const running = new Map();
+// None when Claude Code cannot say (too old for `agents`, not installed): then nothing is known to be open.
+export function listMacClaudes(claudeBin) {
+    const now = running.get(claudeBin);
+    if (now)
+        return now;
+    const next = listNow(claudeBin)
+        .catch(() => [])
+        .finally(() => running.delete(claudeBin));
+    running.set(claudeBin, next);
+    return next;
+}
+async function listNow(claudeBin) {
+    const listings = await Promise.all([...(await configDirs())].map((dir) => run(claudeBin, ['agents', '--json'], dir === undefined ? undefined : { ...process.env, CLAUDE_CONFIG_DIR: dir })
+        .then((out) => JSON.parse(out))
+        .catch(() => [])));
+    const listed = listings.flatMap((l) => (Array.isArray(l) ? l : []));
+    const found = listed.flatMap((a) => a && a.kind === 'interactive' && Number.isSafeInteger(a.pid) && typeof a.sessionId === 'string' && typeof a.cwd === 'string'
+        ? [{ pid: a.pid, sessionId: a.sessionId, cwd: a.cwd, status: STATUSES.has(a.status) ? a.status : 'busy' }]
+        : []);
+    // One dir can be named two ways (this server's own, and set by a terminal to the same path).
+    const interactive = [...new Map(found.map((a) => [a.pid, a])).values()];
+    if (!interactive.length)
+        return [];
+    const procs = await processes(interactive.map((a) => a.pid));
+    return interactive.flatMap((a) => {
+        const p = procs.get(a.pid);
+        return p && !p.inWorkOffDesk ? [{ ...a, tty: p.tty }] : [];
+    });
+}
+// Where Claude Code keeps who is running: each Claude lists itself in its own config dir, and a terminal can
+// set CLAUDE_CONFIG_DIR while sharing the conversations with the rest. undefined: this server's own.
+async function configDirs() {
+    const dirs = new Set([undefined]);
+    const out = await run('/bin/ps', ['-E', '-ww', '-A', '-o', 'command=']).catch((e) => String(e.stdout ?? ''));
+    for (const line of out.split('\n')) {
+        // Claude Code's own program, or the one npm installs, which node runs.
+        if (!/^(\S*\/)?(node\s+(\S*\/)?)?claude(\s|$)/.test(line))
+            continue;
+        const dir = /(?:^|\s)CLAUDE_CONFIG_DIR=(\S+)/.exec(line)?.[1];
+        if (dir)
+            dirs.add(dir);
+    }
+    return dirs;
+}
+// Each process's terminal, and whether it runs in a WorkOffDesk session: every session's program is started
+// with WORKOFFDESK_SESSION, whichever WorkOffDesk on this Mac started it, and what it starts inherits it.
+// One gone since it was listed is left out.
+async function processes(pids) {
+    const out = await run('/bin/ps', ['-E', '-ww', '-o', 'pid=,tty=,command=', '-p', pids.join(',')]).catch((e) => String(e.stdout ?? ''));
+    const procs = new Map();
+    for (const line of out.split('\n')) {
+        const [, pid, tty, command] = /^\s*(\d+)\s+(\S+)\s(.*)$/.exec(line) ?? [];
+        if (!pid)
+            continue;
+        procs.set(Number(pid), { tty: /^ttys?\d+$/.test(tty) ? tty : null, inWorkOffDesk: /(^|\s)WORKOFFDESK_SESSION=\S/.test(command) });
+    }
+    return procs;
+}
+const alive = (pid) => {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (e) {
+        return e.code === 'EPERM';
+    }
+};
+// Tells an agent in a terminal (Claude, Codex) to quit as its own Ctrl-C would, and waits for it to be gone:
+// what it writes is whole then. What it was writing in a turn is lost; what the person sent stays. note: said
+// in the terminal it leaves, under the agent's own resume line, which would open the conversation a second time.
+// False when it would not go in time; it is not killed harder, and must not be resumed while it runs.
+export async function stopMacProcess(c, note) {
+    try {
+        process.kill(c.pid, 'SIGTERM');
+    }
+    catch (e) {
+        if (e.code !== 'ESRCH')
+            throw e;
+    }
+    const until = Date.now() + STOP_MS;
+    while (alive(c.pid)) {
+        if (Date.now() > until)
+            return false;
+        await new Promise((r) => setTimeout(r, STOP_LOOK_MS));
+    }
+    if (c.tty)
+        await say(`/dev/${c.tty}`, note);
+    return true;
+}
+// The terminal may be closed with it (a tab that ran claude alone); then there is no one to tell.
+async function say(tty, note) {
+    try {
+        const fh = await open(tty, 'w');
+        await fh.write(`\r\n${note.replace(/\n/g, '\r\n')}\r\n`).finally(() => fh.close());
+    }
+    catch {
+        // gone with it
+    }
+}