workoffdesk 0.0.0-stage → 1.0.0

package/dist/server/sessions/outbox.js

@@ -0,0 +1,194 @@
+import { randomBytes } from 'node:crypto';
+import { existsSync, readFileSync, renameSync } from 'node:fs';
+import { DomainError } from '../system/errors.js';
+// What is sent while Claude works goes to it at once, into its own queue, which it reads at its next step
+// (journal/ingest.ts follows it there). What is sent while Claude starts or asks something waits here, to be
+// looked over, changed or sent at once: a dialog would take what is typed. Claude takes nothing while it
+// compacts, and an ended session is a shell that would run what it is sent.
+const HOLDS = new Set(['starting', 'waiting', 'compacting', 'ended']);
+// Apart, so Claude takes each message on its own rather than as one paste.
+const GAP_MS = 400;
+const queued = (m) => ({ id: m.id, text: m.text, at: m.sentAt });
+// Where the messages were kept before the journal: read into it once, then set aside as <file>.migrated.
+export function migrateQueueFile(file, store) {
+    if (!existsSync(file))
+        return;
+    const f = JSON.parse(readFileSync(file, 'utf8'));
+    const put = (id, m) => store.messages(id).some((r) => r.id === m.id) || store.putMessage(id, m);
+    const row = (q, state, ord) => ({ id: q.id, text: q.text, sentAt: q.at, state, ord, item: null });
+    for (const [id, list] of Object.entries(f.done ?? {}))
+        for (const qid of list)
+            put(id, { id: qid, text: '', sentAt: 0, state: 'landed', ord: null, item: null });
+    for (const [id, list] of Object.entries(f.sent ?? {}))
+        for (const q of list)
+            put(id, row(q, 'delivered', null));
+    for (const [id, list] of Object.entries(f.sessions ?? {}))
+        list.forEach((q, n) => put(id, row(q, 'queued', n + 1)));
+    renameSync(file, `${file}.migrated`);
+}
+// A delivery that was asked for but not answered (a tmux that timed out) may have gone in: typing it again
+// could put it there twice.
+const mayHaveRun = (e) => e?.mayHaveRun === true;
+// What is sent to a Claude session reaches it in the order it was sent; what it cannot take yet waits, in
+// the journal, through a restart, until it can. Each message is one row whose state says where it is:
+// queued, delivering (being pasted), delivered, landed (the transcript has it), taken back, unconfirmed.
+export class Outbox {
+    store;
+    status;
+    deliver;
+    changed;
+    failed;
+    gapMs;
+    running = new Map();
+    again = new Set();
+    // Messages being pasted from a send, by id, with what a send of the same id answers.
+    pastes = new Map();
+    constructor(deps) {
+        this.store = deps.store;
+        this.status = deps.status;
+        this.deliver = deps.deliver;
+        this.changed = deps.changed;
+        this.failed = deps.failed ?? (() => { });
+        this.gapMs = deps.gapMs ?? GAP_MS;
+    }
+    list(id) {
+        return this.waiting(id).map(queued);
+    }
+    // Null when the message went to Claude at once; otherwise it waits, behind any already waiting. One that
+    // failed to go waits for the next flush rather than being tried again at once. One sent again under the
+    // id it was given (`qid`) is taken once: what it got the first time comes back.
+    async send(id, text, qid = randomBytes(6).toString('hex')) {
+        const pasting = this.pastes.get(qid);
+        if (pasting)
+            return pasting;
+        const known = this.store.messages(id).find((m) => m.id === qid);
+        if (known?.state === 'queued')
+            return queued(known);
+        if (known && known.state !== 'taken')
+            return null;
+        const m = { id: qid, text, sentAt: Date.now(), state: 'queued', ord: null, item: null };
+        if (!this.waiting(id).length && !HOLDS.has(this.status(id))) {
+            return this.pasting(qid, async () => ((await this.paste(id, m)) ? null : (this.put(id, { ...m, ord: this.lastOrd(id) + 1 }), queued(m))));
+        }
+        this.put(id, { ...m, ord: this.lastOrd(id) + 1 });
+        void this.flush(id);
+        return queued(m);
+    }
+    // One run per session at a time; asked again while running, it looks once more before it ends.
+    flush(id) {
+        const run = this.running.get(id);
+        if (run) {
+            this.again.add(id);
+            return run;
+        }
+        // Started after it is registered, so a send made while delivering finds it running; it is unregistered
+        // in the same step that finds nothing more asked of it, so no flush falls between the two.
+        const next = Promise.resolve().then(async () => {
+            try {
+                do {
+                    this.again.delete(id);
+                    await this.deliverHeld(id);
+                } while (this.again.has(id));
+            }
+            finally {
+                this.running.delete(id);
+            }
+        });
+        this.running.set(id, next);
+        return next;
+    }
+    // The text of a message taken back before it went, or null when it is no longer waiting.
+    remove(id, qid) {
+        const m = this.waiting(id).find((w) => w.id === qid);
+        if (!m)
+            return null;
+        this.put(id, { ...m, state: 'taken', ord: null });
+        return m.text;
+    }
+    // Goes to Claude now, whatever it is doing, out of its turn; false when it is not waiting any more. One
+    // that could not go waits again, first, and the caller is told it did not go.
+    async sendNow(id, qid) {
+        const m = this.waiting(id).find((w) => w.id === qid);
+        if (!m)
+            return false;
+        const answer = await this.pasting(qid, async () => {
+            if (await this.paste(id, m))
+                return null;
+            this.put(id, { ...m, state: 'queued', ord: this.firstOrd(id) - 1 });
+            return queued(m);
+        });
+        if (answer)
+            throw new DomainError(503, 'not sent');
+        return true;
+    }
+    // One place earlier (-1) or later (1) among those waiting; false when it is not waiting any more.
+    move(id, qid, by) {
+        const list = this.waiting(id);
+        const i = list.findIndex((m) => m.id === qid);
+        if (i < 0)
+            return false;
+        const j = Math.max(0, Math.min(list.length - 1, i + by));
+        if (i === j)
+            return true;
+        this.put(id, { ...list[i], ord: list[j].ord });
+        this.put(id, { ...list[j], ord: list[i].ord });
+        return true;
+    }
+    async deliverHeld(id) {
+        let first = true;
+        for (let m = this.waiting(id)[0]; m && !HOLDS.has(this.status(id)); m = this.waiting(id)[0]) {
+            if (!first)
+                await new Promise((r) => setTimeout(r, this.gapMs));
+            first = false;
+            // Taken back or moved during the gap.
+            if (this.waiting(id)[0]?.id !== m.id)
+                continue;
+            if (!(await this.paste(id, m))) {
+                this.put(id, { ...m, state: 'queued' });
+                this.again.delete(id);
+                return;
+            }
+        }
+    }
+    // Pastes the message, recorded as delivering until it is in: true once it is (or may be, after a paste
+    // that was asked for and not answered), false when it did not go; then the caller says where it waits.
+    // Typed while Claude works, it goes into Claude's own queue, and is said to from the start (enqueued),
+    // so no device sees it anywhere else on the way.
+    async paste(id, m) {
+        this.put(id, { ...m, state: this.status(id) === 'working' ? 'enqueued' : 'delivering', ord: null });
+        let went = true;
+        try {
+            await this.deliver(id, m.text, m.id);
+        }
+        catch (e) {
+            this.failed(id, e);
+            went = mayHaveRun(e);
+        }
+        // The transcript may have shown it landed before the paste answered.
+        if (went && this.store.messages(id).find((r) => r.id === m.id)?.state === 'delivering')
+            this.put(id, { ...m, state: 'delivered', ord: null });
+        return went;
+    }
+    // Known as being delivered from before the paste starts until it is recorded as sent or held again.
+    pasting(qid, paste) {
+        const answer = paste().finally(() => this.pastes.delete(qid));
+        this.pastes.set(qid, answer);
+        return answer;
+    }
+    waiting(id) {
+        return this.store
+            .messages(id)
+            .filter((m) => m.state === 'queued')
+            .sort((a, b) => (a.ord ?? 0) - (b.ord ?? 0));
+    }
+    lastOrd(id) {
+        return this.waiting(id).at(-1)?.ord ?? 0;
+    }
+    firstOrd(id) {
+        return this.waiting(id)[0]?.ord ?? 0;
+    }
+    put(id, m) {
+        this.store.putMessage(id, m);
+        this.changed();
+    }
+}

package/dist/server/sessions/panes.js

@@ -0,0 +1,60 @@
+import { execFile } from 'node:child_process';
+// An agent session's pane starts as `<shell> -lc '<agent> …; exec <shell> -l'`. That process waits for the
+// agent and, however the agent ends, becomes the login shell: while its command line is still the wrapper's,
+// the agent runs.
+const WRAPPER = /^\S+ -lc /;
+const LOOK_MS = 5_000;
+const QUIT_LOOK_MS = 100;
+const run = (bin, args) => new Promise((resolve) => execFile(bin, args, { timeout: LOOK_MS }, (err, stdout) => {
+    const code = err ? err.code : 0;
+    resolve(typeof code === 'number' ? { code, out: String(stdout) } : null);
+}));
+// Per pane process, whether the agent it was started with runs; one gone is not running. Null when it could not
+// be looked at.
+export async function agentsRunning(pids) {
+    if (!pids.length)
+        return new Map();
+    // ps leaves out the processes that are gone, and then exits 1.
+    const r = await run('/bin/ps', ['-ww', '-o', 'pid=,args=', '-p', pids.join(',')]);
+    if (!r || r.code > 1)
+        return null;
+    const args = new Map();
+    for (const line of r.out.split('\n')) {
+        const [, pid, command] = /^\s*(\d+)\s(.*)$/.exec(line) ?? [];
+        if (pid)
+            args.set(Number(pid), command);
+    }
+    return new Map(pids.map((pid) => [pid, WRAPPER.test(args.get(pid) ?? '')]));
+}
+// What runs under a pane process: its agent, while the agent runs; a program started from a terminal on the Mac,
+// in the shell a pane was left with.
+async function childrenOf(pid) {
+    const r = await run('/usr/bin/pgrep', ['-P', String(pid)]);
+    if (!r || r.code > 1)
+        throw new Error(`could not look at what runs under process ${pid}`);
+    return r.out.split('\n').filter(Boolean).map(Number);
+}
+export async function shellBusy(pid) {
+    return (await childrenOf(pid)).length > 0;
+}
+// Asks the agent a pane runs to quit, as a terminal's is when it is taken over, and waits for it at most waitMs:
+// true once it no longer runs.
+export async function quitAgent(pid, waitMs) {
+    for (const child of await childrenOf(pid)) {
+        try {
+            process.kill(child, 'SIGTERM');
+        }
+        catch (e) {
+            if (e.code !== 'ESRCH')
+                throw e;
+        }
+    }
+    const until = Date.now() + waitMs;
+    for (;;) {
+        if ((await agentsRunning([pid]))?.get(pid) === false)
+            return true;
+        if (Date.now() > until)
+            return false;
+        await new Promise((r) => setTimeout(r, QUIT_LOOK_MS));
+    }
+}

package/dist/server/sessions/sessionName.js

@@ -0,0 +1,7 @@
+// A session's tmux session is named for it, so the sessions this server runs are told apart from any other
+// on the same tmux server.
+const PREFIX = 'wod-';
+export const tmuxName = (id) => PREFIX + id;
+export function idOfTmuxName(name) {
+    return name.startsWith(PREFIX) ? name.slice(PREFIX.length) : undefined;
+}

package/dist/server/sessions/terminalEnv.js

@@ -0,0 +1,40 @@
+import { execFile } from 'node:child_process';
+// What a Claude started here in a terminal's place keeps of that terminal's environment: all of it, so what
+// was set up there goes on working (a virtualenv, a cloud profile, the hooks of the app the terminal is in),
+// but for what describes the terminal itself, which tmux sets anew, and what marks a program run inside another.
+const OF_THE_TERMINAL = new Set([
+    'TERM',
+    'TERM_PROGRAM',
+    'TERM_PROGRAM_VERSION',
+    'COLORTERM',
+    'TMUX',
+    'TMUX_PANE',
+    'SHLVL',
+    'PWD',
+    'OLDPWD',
+    '_',
+    'CLAUDECODE',
+    'CLAUDE_CODE_ENTRYPOINT',
+    'WORKOFFDESK_SESSION',
+]);
+// A shell's exported functions (BASH_FUNC_name%%) are not variables tmux can set; the login shell defines its own.
+const NAME = /^[A-Za-z_][A-Za-z0-9_]*$/;
+export function fromTerminal(env) {
+    return Object.fromEntries(Object.entries(env).filter((e) => typeof e[1] === 'string' && NAME.test(e[0]) && !OF_THE_TERMINAL.has(e[0])));
+}
+const PS_MS = 5_000;
+const ps = (args) => new Promise((resolve, reject) => execFile('/bin/ps', ['-ww', ...args], { timeout: PS_MS, maxBuffer: 16 * 1024 * 1024 }, (err, stdout) => err ? reject(err) : resolve(String(stdout).replace(/\n$/, ''))));
+// The environment a process of this user started with, as ps shows it after its arguments: NAME=value, one
+// after another with a space between, so a value holding " NAME=" is cut there. Empty when it is gone.
+export async function environmentOf(pid) {
+    const [args, withEnv] = await Promise.all([ps(['-o', 'args=', '-p', String(pid)]), ps(['-E', '-o', 'args=', '-p', String(pid)])]).catch(() => ['', '']);
+    if (!args || !withEnv.startsWith(`${args} `))
+        return {};
+    return Object.fromEntries(withEnv
+        .slice(args.length + 1)
+        .split(/ (?=[A-Za-z_][A-Za-z0-9_]*=)/)
+        .flatMap((pair) => {
+        const at = pair.indexOf('=');
+        return at > 0 ? [[pair.slice(0, at), pair.slice(at + 1)]] : [];
+    }));
+}

package/dist/server/system/config.js

@@ -0,0 +1,71 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { m } from './messages.js';
+import { writeJsonAtomic } from './paths.js';
+export const DEFAULT_PORT = 7681;
+export const DEFAULT_SERVICE_LABEL = 'local.workoffdesk';
+export class ConfigError extends Error {
+    field;
+    expected;
+    constructor(field, expected) {
+        super(m.config.wrong(field, expected));
+        this.field = field;
+        this.expected = expected;
+    }
+}
+const LOCAL = /^http:\/\/(localhost|127\.0\.0\.1)(:\d+)?$/;
+const isStrings = (v) => Array.isArray(v) && v.every((x) => typeof x === 'string');
+function originUrl(origin) {
+    if (typeof origin !== 'string')
+        return null;
+    try {
+        const url = new URL(origin);
+        return url.origin === origin && (url.protocol === 'https:' || LOCAL.test(origin)) ? url : null;
+    }
+    catch {
+        return null;
+    }
+}
+export function parseConfig(raw) {
+    const r = (raw && typeof raw === 'object' ? raw : {});
+    const url = originUrl(r.origin);
+    if (!url)
+        throw new ConfigError('origin', m.config.origin);
+    const port = r.port ?? DEFAULT_PORT;
+    if (typeof port !== 'number' || !Number.isInteger(port) || port < 1 || port > 65535)
+        throw new ConfigError('port', m.config.port);
+    const rpId = r.rpId ?? url.hostname;
+    if (typeof rpId !== 'string' || !(url.hostname === rpId || url.hostname.endsWith(`.${rpId}`))) {
+        throw new ConfigError('rpId', m.config.rpId(url.hostname));
+    }
+    const pinnedDirs = r.pinnedDirs ?? [];
+    if (!isStrings(pinnedDirs))
+        throw new ConfigError('pinnedDirs', m.config.pinnedDirs);
+    const serviceLabel = r.serviceLabel ?? DEFAULT_SERVICE_LABEL;
+    if (typeof serviceLabel !== 'string' || !/^[A-Za-z0-9.-]+$/.test(serviceLabel)) {
+        throw new ConfigError('serviceLabel', m.config.serviceLabel);
+    }
+    const claudeArgs = r.claudeArgs ?? [];
+    if (!isStrings(claudeArgs))
+        throw new ConfigError('claudeArgs', m.config.claudeArgs);
+    const preventSleep = r.preventSleep ?? true;
+    if (typeof preventSleep !== 'boolean')
+        throw new ConfigError('preventSleep', m.config.preventSleep);
+    return { port, origin: url.origin, rpId, pinnedDirs, serviceLabel, claudeArgs, preventSleep };
+}
+export function loadConfig(home) {
+    const file = join(home, 'config.json');
+    if (!existsSync(file))
+        throw new ConfigError('origin', m.config.missing(file));
+    let raw;
+    try {
+        raw = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch (e) {
+        throw new ConfigError(m.config.format, m.config.notJson(e.message));
+    }
+    return parseConfig(raw);
+}
+export function writeConfig(home, c) {
+    writeJsonAtomic(join(home, 'config.json'), c);
+}

package/dist/server/system/dirs.js

@@ -0,0 +1,54 @@
+import { statSync } from 'node:fs';
+import { readdir, realpath, stat } from 'node:fs/promises';
+import { join, resolve, sep } from 'node:path';
+// How many folders one listing gives at most: the picker shows a screenful, and typing narrows it.
+export const DIRS_MAX = 50;
+export function isDir(path) {
+    try {
+        return statSync(path).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+// A path as typed, with a leading ~ standing for home; anything else as it is.
+export function expandHome(path, home) {
+    if (path === '~')
+        return home;
+    if (path.startsWith('~/'))
+        return join(home, path.slice(2));
+    return path;
+}
+const within = (path, root) => path === root || path.startsWith(root.endsWith(sep) ? root : root + sep);
+const realOrNull = (path) => realpath(path).catch(() => null);
+const byName = (a, b) => a.localeCompare(b, 'en', { sensitivity: 'base' });
+// The folders a path typed in the new-session picker points into: those in the folder before its last '/'
+// whose names start with what comes after it, ignoring case, and those named with a leading '.' only when
+// that part has one too. Nothing outside home is listed, however it is reached (.., a link).
+export async function listDirs(typed, home) {
+    const path = typed === '~' ? '~/' : typed;
+    const cut = path.lastIndexOf('/');
+    const parent = expandHome(path.slice(0, cut + 1), home);
+    if (!parent.startsWith('/'))
+        return [];
+    const dir = resolve(parent);
+    const prefix = path.slice(cut + 1).toLowerCase();
+    const [realHome, realDir] = await Promise.all([realOrNull(home), realOrNull(dir)]);
+    if (!realHome || !realDir || !within(realDir, realHome))
+        return [];
+    const entries = await readdir(dir, { withFileTypes: true }).catch(() => []);
+    const names = entries
+        .filter((e) => (e.isDirectory() || e.isSymbolicLink()) && e.name.toLowerCase().startsWith(prefix))
+        .filter((e) => prefix.startsWith('.') || !e.name.startsWith('.'))
+        .map((e) => e.name)
+        .sort(byName);
+    const out = [];
+    for (const name of names) {
+        if (out.length === DIRS_MAX)
+            break;
+        const real = await realOrNull(join(dir, name));
+        if (real && within(real, realHome) && (await stat(real).then((s) => s.isDirectory(), () => false)))
+            out.push(join(dir, name));
+    }
+    return out;
+}

package/dist/server/system/errors.js

@@ -0,0 +1,37 @@
+// What can go wrong in a way the caller should hear about, with the HTTP status it is answered with.
+// Anything else is the server's own fault: answered 500 with no detail, and logged in full.
+// code: for the ones the phone shows, which it says in the phone's own language.
+export class DomainError extends Error {
+    status;
+    code;
+    constructor(status, message, code) {
+        super(message);
+        this.status = status;
+        this.code = code;
+    }
+}
+export class InvalidRequest extends DomainError {
+    constructor(message, code) {
+        super(400, message, code);
+    }
+}
+export class NotFound extends DomainError {
+    constructor(message) {
+        super(404, message);
+    }
+}
+export class Conflict extends DomainError {
+    constructor(message, code) {
+        super(409, message, code);
+    }
+}
+export class UnsupportedMedia extends DomainError {
+    constructor(message, code) {
+        super(415, message, code);
+    }
+}
+export function errorReply(e) {
+    if (!(e instanceof DomainError))
+        return { status: 500, body: { error: 'server error' } };
+    return { status: e.status, body: e.code ? { error: e.message, code: e.code } : { error: e.message } };
+}

package/dist/server/system/log.js

@@ -0,0 +1,40 @@
+import { appendFileSync, existsSync, mkdirSync, renameSync, rmSync, statSync } from 'node:fs';
+import { dirname } from 'node:path';
+import pino from 'pino';
+export const REDACT = ['req.headers.cookie', 'req.headers.authorization', 'req.body.password', 'res.headers["set-cookie"]'];
+// A log file that is moved aside to .1 when it is full, the older ones moving up to .keep and then gone.
+// Writes are synchronous: the lines are few and short, and none is lost when the process exits.
+export class RotatingFile {
+    path;
+    size;
+    maxBytes;
+    keep;
+    constructor(path, o = {}) {
+        this.path = path;
+        this.maxBytes = o.maxBytes ?? 10 * 1024 * 1024;
+        this.keep = o.keep ?? 3;
+        mkdirSync(dirname(path), { recursive: true });
+        this.size = existsSync(path) ? statSync(path).size : 0;
+    }
+    write(chunk) {
+        const bytes = Buffer.byteLength(chunk);
+        if (this.size > 0 && this.size + bytes > this.maxBytes)
+            this.rotate();
+        appendFileSync(this.path, chunk, { mode: 0o600 });
+        this.size += bytes;
+        return true;
+    }
+    rotate() {
+        rmSync(`${this.path}.${this.keep}`, { force: true });
+        for (let n = this.keep - 1; n >= 1; n--) {
+            if (existsSync(`${this.path}.${n}`))
+                renameSync(`${this.path}.${n}`, `${this.path}.${n + 1}`);
+        }
+        renameSync(this.path, `${this.path}.1`);
+        this.size = 0;
+    }
+}
+export function createLogger(o = {}) {
+    const destination = o.file ? new RotatingFile(o.file) : process.stdout;
+    return pino({ level: o.level ?? 'info', redact: { paths: REDACT, censor: '[redacted]' } }, destination);
+}