workoffdesk 0.0.0-stage → 1.0.0

package/dist/server/commands/open.js

@@ -0,0 +1,31 @@
+import { spawnSync } from 'node:child_process';
+import { join } from 'node:path';
+import { askToOpen } from '../sessions/control.js';
+import { tmuxName } from '../sessions/sessionName.js';
+import { fromTerminal } from '../sessions/terminalEnv.js';
+import { m } from '../system/messages.js';
+import { homeDir, socketPath, tmuxSocketFor } from '../system/paths.js';
+import { Tmux } from '../system/tmux.js';
+import { fail, flag } from './common.js';
+// A Claude or Codex session opened in this terminal's directory and joined at once: this Mac has it as a
+// terminal, the phone as a chat.
+export async function openHere(kind, args) {
+    const home = homeDir();
+    const resumeId = flag(args, 'resume');
+    let id;
+    try {
+        id = await askToOpen(socketPath(home, 'control.sock'), {
+            kind,
+            cwd: process.cwd(),
+            ...(resumeId ? { resumeId } : {}),
+            ...(kind === 'claude' ? { env: fromTerminal(process.env) } : {}),
+        });
+    }
+    catch (e) {
+        const code = e.code;
+        fail(code === 'ENOENT' || code === 'ECONNREFUSED' ? m.cli.notRunning : m.cli.couldNotOpen(e.message));
+    }
+    const tmux = new Tmux({ socket: tmuxSocketFor(home), conf: join(home, 'tmux.conf') });
+    const r = spawnSync(tmux.bin, tmux.attachArgs(tmuxName(id)), { stdio: 'inherit', env: tmux.env() });
+    process.exit(r.status ?? 0);
+}

package/dist/server/commands/qr.js

@@ -0,0 +1,33 @@
+import qrcode from 'qrcode-generator';
+const BORDER = 2;
+// Two modules to a character, the upper and the lower.
+const HALF = { '11': '█', '10': '▀', '01': '▄', '00': ' ' };
+// The address as a QR code for the phone's camera, drawn black on white whatever the terminal's colors.
+// A local address has nothing for a phone to open, so it gets none.
+export function originQr(origin) {
+    if (!origin.startsWith('https://'))
+        return '';
+    const qr = qrcode(0, 'M');
+    qr.addData(origin);
+    qr.make();
+    const n = qr.getModuleCount();
+    const size = n + 2 * BORDER;
+    const dark = (r, c) => r >= BORDER && c >= BORDER && r < BORDER + n && c < BORDER + n && qr.isDark(r - BORDER, c - BORDER);
+    const lines = [];
+    for (let r = 0; r < size; r += 2) {
+        let line = '';
+        for (let c = 0; c < size; c++)
+            line += HALF[`${+dark(r, c)}${+dark(r + 1, c)}`];
+        lines.push(`\x1b[30;47m${line}\x1b[0m`);
+    }
+    return lines.join('\n');
+}
+// The same, as an SVG for a page: the setup wizard's last step.
+export function originQrSvg(origin) {
+    if (!origin.startsWith('https://'))
+        return '';
+    const qr = qrcode(0, 'M');
+    qr.addData(origin);
+    qr.make();
+    return qr.createSvgTag({ cellSize: 6, margin: 4 * 6, scalable: true });
+}

package/dist/server/commands/serve.js

@@ -0,0 +1,45 @@
+import { spawn } from 'node:child_process';
+import { NotSetUp, startServer } from '../http/serve.js';
+import { keepAwake } from '../ops/awake.js';
+import { runDoctor } from '../ops/doctor.js';
+import { isManaged } from '../ops/service.js';
+import { shutdownOnce } from '../ops/shutdown.js';
+import { m } from '../system/messages.js';
+import { homeDir } from '../system/paths.js';
+import { ACTIVATED_FILE, APP_UPDATE_DIR, PACKAGE_ROOT, WEB_DIR, fail, loadConfigOrFail, spawnOp } from './common.js';
+import { doctorDeps } from './doctor.js';
+export async function serve() {
+    const home = homeDir();
+    const config = loadConfigOrFail(home, 78);
+    let server;
+    try {
+        server = await startServer({
+            home,
+            config,
+            webDir: WEB_DIR,
+            // A release is the whole package folder, dist/server/cli.js inside it.
+            appUpdate: { dir: APP_UPDATE_DIR, activatedFile: ACTIVATED_FILE },
+            ops: {
+                home,
+                managed: isManaged(process.env, config.serviceLabel),
+                startedAt: Date.now(),
+                buildRoot: PACKAGE_ROOT,
+                doctor: (messages) => runDoctor({ ...doctorDeps(home), messages }),
+                spawnOp: (op) => spawnOp(home, op),
+            },
+        });
+    }
+    catch (e) {
+        if (e instanceof NotSetUp)
+            fail(m.cli.notSetUp);
+        throw e;
+    }
+    await server.app.listen({ port: config.port, host: '127.0.0.1' });
+    server.app.log.info({ port: config.port, origin: config.origin }, 'started');
+    keepAwake({ enabled: config.preventSleep, platform: process.platform, pid: process.pid, spawn, log: (msg, err) => server.app.log.warn({ err }, msg) });
+    if (process.stdout.isTTY)
+        console.log(m.cli.running(config.port, config.origin));
+    const stop = shutdownOnce(server.close, { timeoutMs: 10_000, exit: (code) => process.exit(code) });
+    process.on('SIGTERM', stop);
+    process.on('SIGINT', stop);
+}

package/dist/server/commands/service.js

@@ -0,0 +1,87 @@
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { createServer } from 'node:net';
+import { homedir, tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { deploy, healthOn, rollback } from '../ops/release.js';
+import { restartService, startService, stopService } from '../ops/service.js';
+import { m } from '../system/messages.js';
+import { envForHome, homeDir } from '../system/paths.js';
+import { HEALTH_WAIT_MS, exec, fail, loadConfigOrFail, record } from './common.js';
+import { servicePath } from './install.js';
+function freePort() {
+    return new Promise((done, reject) => {
+        const s = createServer().once('error', reject);
+        s.listen(0, '127.0.0.1', () => {
+            const { port } = s.address();
+            s.close(() => done(port));
+        });
+    });
+}
+// Runs the build's own smoke script against a throwaway home, with the node this command runs on.
+async function smoke(appDir) {
+    const home = mkdtempSync(join(tmpdir(), 'ts-smoke-'));
+    try {
+        const port = await freePort();
+        const child = spawn(process.execPath, [join(appDir, 'scripts/smoke.mjs')], {
+            env: { ...envForHome(process.env, home), APP: appDir, PORT: String(port), SMOKE_HOME: home },
+            stdio: 'inherit',
+        });
+        return await new Promise((done) => child.once('exit', (code) => done(code === 0)));
+    }
+    finally {
+        rmSync(home, { recursive: true, force: true });
+    }
+}
+function releaseDeps() {
+    const home = homeDir();
+    const config = loadConfigOrFail(home);
+    return { home, label: config.serviceLabel, uid: process.getuid(), exec, smoke, health: healthOn(config.port, HEALTH_WAIT_MS) };
+}
+function serviceDeps() {
+    const home = homeDir();
+    const config = loadConfigOrFail(home);
+    return { home, port: config.port, label: config.serviceLabel, uid: process.getuid(), exec };
+}
+export async function startCommand() {
+    const d = serviceDeps();
+    const plist = servicePath(homedir(), d.label);
+    if (!existsSync(plist))
+        fail(m.doctor.installFix);
+    await startService(d, plist).catch((e) => fail(e.message));
+    const up = await healthOn(d.port, HEALTH_WAIT_MS)(null);
+    console.log(up ? m.ops.started(d.port) : m.ops.notUp(join(d.home, 'logs/server.log')));
+    if (!up)
+        process.exit(1);
+}
+export async function stopCommand() {
+    await stopService(serviceDeps()).catch((e) => fail(e.message));
+    console.log(m.ops.stopped);
+}
+export async function restartCommand(args) {
+    const d = serviceDeps();
+    await restartService(d);
+    const up = await healthOn(d.port, HEALTH_WAIT_MS)(null);
+    const message = up ? m.ops.restarted : m.ops.notUp(join(d.home, 'logs/server.log'));
+    record(args, d.home, { ok: up, message });
+    console.log(message);
+    if (!up)
+        process.exit(1);
+}
+export async function deployCommand(args) {
+    const [dir, ...flags] = args;
+    if (!dir || dir.startsWith('-') || flags.some((f) => f !== '--new-app-runtime'))
+        fail(m.cli.deployUsage);
+    const r = await deploy(resolve(dir), releaseDeps(), { newAppRuntime: flags.includes('--new-app-runtime') });
+    console.log(r.message);
+    if (!r.ok)
+        process.exit(1);
+}
+export async function rollbackCommand(args) {
+    const d = releaseDeps();
+    const r = await rollback(d);
+    record(args, d.home, r);
+    console.log(r.message);
+    if (!r.ok)
+        process.exit(1);
+}

package/dist/server/commands/setup.js

@@ -0,0 +1,36 @@
+import { join } from 'node:path';
+import { hashPassword, MIN_PASSWORD } from '../http/auth/password.js';
+import { writeConfig } from '../system/config.js';
+import { m } from '../system/messages.js';
+import { homeDir } from '../system/paths.js';
+import { Store } from '../system/store.js';
+import { ask, configForSetup, fail, flag, readStdinLine, showQr } from './common.js';
+import { setupWeb } from './setupWeb.js';
+export async function setup(args) {
+    if (args.includes('--web'))
+        return setupWeb();
+    const home = homeDir();
+    const config = await configForSetup(home, flag(args, 'origin'));
+    const username = flag(args, 'username') ?? (await ask(m.cli.askUsername)).trim();
+    if (!username)
+        fail(m.cli.emptyUsername);
+    let password;
+    if (process.stdin.isTTY) {
+        password = await ask(m.cli.askPassword(MIN_PASSWORD), true);
+        if ((await ask(m.cli.askAgain, true)) !== password)
+            fail(m.cli.passwordsDiffer);
+    }
+    else {
+        password = await readStdinLine();
+    }
+    if ([...password].length < MIN_PASSWORD)
+        fail(m.cli.passwordTooShort(MIN_PASSWORD));
+    const hash = await hashPassword(password);
+    new Store(join(home, 'state.json')).update((s) => {
+        s.user = { username, hash };
+        s.logins = [];
+    });
+    writeConfig(home, config);
+    console.log(m.cli.setUp(username, config.origin, join(home, 'config.json'), config.port));
+    showQr(config.origin);
+}

package/dist/server/commands/setupWeb.js

@@ -0,0 +1,87 @@
+import { execFile } from 'node:child_process';
+import { randomBytes } from 'node:crypto';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { runDoctor } from '../ops/doctor.js';
+import { healthOn } from '../ops/release.js';
+import { startService } from '../ops/service.js';
+import { loadConfig } from '../system/config.js';
+import { m } from '../system/messages.js';
+import { homeDir } from '../system/paths.js';
+import { HEALTH_WAIT_MS, WEB_DIR, exec, which } from './common.js';
+import { doctorDeps } from './doctor.js';
+import { installPlan, installService } from './install.js';
+import { tailscaleOf, tunnelsOf } from './wizard/probe.js';
+import { buildWizard } from './wizard/server.js';
+const TAILSCALE_APP = '/Applications/Tailscale.app/Contents/MacOS/Tailscale';
+// The Mac App Store's Tailscale puts no command on PATH; its app carries one.
+const tool = (name) => which(name) ?? (name === 'tailscale' && existsSync(TAILSCALE_APP) ? TAILSCALE_APP : undefined);
+const stdoutOf = (cmd, args) => new Promise((done) => execFile(cmd, args, { timeout: 10_000 }, (err, stdout) => done(err ? null : stdout)));
+async function probeRemote() {
+    const tailscale = tool('tailscale');
+    const cloudflared = tool('cloudflared');
+    const [ts, cf] = await Promise.all([
+        tailscale ? stdoutOf(tailscale, ['status', '--json']) : null,
+        cloudflared ? stdoutOf(cloudflared, ['tunnel', 'list', '--output', 'json']) : null,
+    ]);
+    return { tailscale: tailscale ? tailscaleOf(ts) : null, cloudflared: cloudflared ? { tunnels: tunnelsOf(cf) } : null };
+}
+// The wizard's service step: what install writes, the tunnel's DNS record, both agents started, and the
+// service waited for.
+async function installFromWizard(home, tunnelName) {
+    try {
+        const config = loadConfig(home);
+        const plan = installPlan(tunnelName ? ['--tunnel', tunnelName] : [], home, config);
+        const { warnings, servicePlist, tunnelPlist } = installService(plan);
+        const d = { uid: process.getuid(), label: config.serviceLabel, exec };
+        if (plan.tunnel && tunnelName && tunnelPlist) {
+            const route = await exec(plan.tunnel.cloudflared, ['tunnel', '--config', join(home, 'cloudflared.yml'), 'route', 'dns', tunnelName, new URL(config.origin).hostname]);
+            // A record the hostname already has is left as it is, as cloudflared does.
+            if (route.code !== 0 && !/already exists/i.test(route.out))
+                return { ok: false, message: m.wizard.routeFailed(route.out.trim()) };
+            await startService({ ...d, label: `${config.serviceLabel}-tunnel` }, tunnelPlist);
+        }
+        await startService(d, servicePlist);
+        const up = await healthOn(config.port, HEALTH_WAIT_MS)(null);
+        return { ok: up, message: [up ? m.ops.started(config.port) : m.ops.notUp(join(home, 'logs/server.log')), ...warnings].join('\n') };
+    }
+    catch (e) {
+        return { ok: false, message: e.message };
+    }
+}
+const WIZARD_IDLE_MS = 30 * 60_000;
+// The first install in the browser (wizard/server.ts), on loopback at a free port, guarded by a token that
+// travels in the address's fragment.
+export async function setupWeb() {
+    const home = homeDir();
+    const token = randomBytes(24).toString('base64url');
+    let host = '';
+    let idle;
+    const end = (message) => {
+        clearTimeout(idle);
+        console.log(message);
+        void app.close().finally(() => process.exit(0));
+    };
+    const app = await buildWizard({
+        home,
+        webDir: WEB_DIR,
+        token,
+        host: () => host,
+        doctor: () => runDoctor(doctorDeps(home)),
+        probe: probeRemote,
+        run: (cmd, args) => exec(tool(cmd) ?? cmd, args),
+        install: (o) => installFromWizard(home, o.tunnel),
+        // After the answer has gone out.
+        onDone: () => setTimeout(() => end(m.wizard.done), 200),
+        touch: () => {
+            clearTimeout(idle);
+            idle = setTimeout(() => end(m.wizard.idle), WIZARD_IDLE_MS);
+        },
+    });
+    await app.listen({ host: '127.0.0.1', port: 0 });
+    host = `127.0.0.1:${app.server.address().port}`;
+    const url = `http://${host}/setup#${token}`;
+    console.log(m.wizard.open(url));
+    execFile('open', [url], () => { });
+    idle = setTimeout(() => end(m.wizard.idle), WIZARD_IDLE_MS);
+}

package/dist/server/commands/status.js

@@ -0,0 +1,32 @@
+import { join } from 'node:path';
+import { runDoctor } from '../ops/doctor.js';
+import { recentProblems } from '../ops/problems.js';
+import { macReport } from '../ops/report.js';
+import { loadConfig } from '../system/config.js';
+import { m } from '../system/messages.js';
+import { homeDir } from '../system/paths.js';
+import { PACKAGE_ROOT, fail } from './common.js';
+import { doctorDeps } from './doctor.js';
+// What the menu bar app shows: the checks, the build, the releases and the recent problems, as JSON.
+export async function status(args) {
+    if (!args.includes('--json'))
+        fail(m.cli.statusUsage);
+    const home = homeDir();
+    let config = null;
+    try {
+        config = loadConfig(home);
+    }
+    catch {
+        // not set up yet: the checks say so
+    }
+    const report = await macReport({ home, managed: false, startedAt: 0, buildRoot: PACKAGE_ROOT, doctor: (messages) => runDoctor({ ...doctorDeps(home), messages }), spawnOp: () => 0 }, m);
+    const { managed: _managed, startedAt: _startedAt, ...rest } = report;
+    console.log(JSON.stringify({
+        ...rest,
+        home,
+        origin: config?.origin ?? null,
+        port: config?.port ?? null,
+        running: report.checks.some((c) => c.id === 'service' && c.ok),
+        problems: recentProblems(join(home, 'logs/workoffdesk.log'), 20),
+    }));
+}

package/dist/server/commands/wizard/probe.js

@@ -0,0 +1,19 @@
+// What the wizard reads of `tailscale status --json` and `cloudflared tunnel list --output json`; out is the
+// command's stdout, null when it failed to run.
+const parse = (out) => {
+    try {
+        return out === null ? null : JSON.parse(out);
+    }
+    catch {
+        return null;
+    }
+};
+export function tailscaleOf(out) {
+    const s = parse(out);
+    const dnsName = typeof s?.Self?.DNSName === 'string' ? s.Self.DNSName.replace(/\.$/, '') : '';
+    return { dnsName, running: s?.BackendState === 'Running' && dnsName !== '' };
+}
+export function tunnelsOf(out) {
+    const list = parse(out);
+    return Array.isArray(list) ? list.map((t) => t?.name).filter((n) => typeof n === 'string') : [];
+}

package/dist/server/commands/wizard/server.js

@@ -0,0 +1,162 @@
+import { timingSafeEqual } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import fastifyStatic from '@fastify/static';
+import Fastify from 'fastify';
+import { hashPassword, MIN_PASSWORD } from '../../http/auth/password.js';
+import { ConfigError, DEFAULT_PORT, loadConfig, parseConfig, writeConfig } from '../../system/config.js';
+import { Conflict, DomainError, errorReply, InvalidRequest } from '../../system/errors.js';
+import { m } from '../../system/messages.js';
+import { originQrSvg } from '../qr.js';
+import { Store } from '../../system/store.js';
+const sameToken = (given, token) => {
+    if (typeof given !== 'string')
+        return false;
+    const a = Buffer.from(given);
+    const b = Buffer.from(token);
+    return a.length === b.length && timingSafeEqual(a, b);
+};
+// The config as it is, even one that no longer parses, so what it holds besides the address is kept.
+function configThere(home) {
+    try {
+        const raw = JSON.parse(readFileSync(join(home, 'config.json'), 'utf8'));
+        return raw && typeof raw === 'object' ? raw : {};
+    }
+    catch {
+        return {};
+    }
+}
+function configFor(home, origin) {
+    const there = configThere(home);
+    try {
+        // Passkeys belong to the rpId, so it is kept unless the site moves to another address.
+        return parseConfig({ ...there, origin, rpId: there.origin === origin ? there.rpId : undefined });
+    }
+    catch (e) {
+        if (e instanceof ConfigError)
+            throw new InvalidRequest(e.message);
+        throw e;
+    }
+}
+function configNow(home) {
+    try {
+        return loadConfig(home);
+    }
+    catch {
+        return null;
+    }
+}
+const HOSTNAME = /^(?=.{1,253}$)([a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/i;
+export async function buildWizard(d) {
+    const app = Fastify({ trustProxy: false, bodyLimit: 16 * 1024 });
+    const store = new Store(join(d.home, 'state.json'));
+    // The tunnel the address step chose, for the service step to run; another address forgets it.
+    let tunnel;
+    app.setErrorHandler((e, _req, reply) => {
+        const own = e;
+        if (!(e instanceof DomainError) && own.statusCode && own.statusCode < 500)
+            return reply.code(own.statusCode).send({ error: own.message });
+        const { status, body } = errorReply(e);
+        return reply.code(status).send(body);
+    });
+    app.addHook('onRequest', async (req, reply) => {
+        d.touch?.();
+        const host = d.host();
+        // Another site's page can reach this port by a name of its own that resolves here (DNS rebinding), but
+        // its requests carry that name.
+        if (req.headers.host !== host)
+            return reply.code(403).send({ error: 'forbidden' });
+        if (!req.url.startsWith('/api/'))
+            return;
+        if (!sameToken(req.headers['x-setup-token'], d.token))
+            return reply.code(403).send({ error: 'forbidden' });
+        if (req.method !== 'GET' && req.headers.origin !== `http://${host}`)
+            return reply.code(403).send({ error: 'forbidden' });
+    });
+    app.addHook('onSend', async (req, reply, payload) => {
+        reply.header('content-security-policy', "default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; frame-ancestors 'none'; base-uri 'none'");
+        reply.header('x-frame-options', 'DENY');
+        reply.header('x-content-type-options', 'nosniff');
+        reply.header('referrer-policy', 'no-referrer');
+        reply.header('cache-control', req.url.startsWith('/assets/') ? 'public, max-age=31536000, immutable' : 'no-store');
+        return payload;
+    });
+    app.get('/api/setup/state', async () => {
+        const config = configNow(d.home);
+        const [checks, remote] = await Promise.all([d.doctor(), d.probe()]);
+        const user = store.get().user;
+        return {
+            checks,
+            user: user ? user.username : null,
+            origin: config?.origin ?? null,
+            port: config?.port ?? DEFAULT_PORT,
+            qr: config ? originQrSvg(config.origin) || null : null,
+            remote,
+        };
+    });
+    app.post('/api/setup/account', async (req) => {
+        const username = typeof req.body?.username === 'string' ? req.body.username.trim() : '';
+        const password = typeof req.body?.password === 'string' ? req.body.password : '';
+        if (!username)
+            throw new InvalidRequest(m.cli.emptyUsername);
+        if ([...password].length < MIN_PASSWORD)
+            throw new InvalidRequest(m.cli.passwordTooShort(MIN_PASSWORD));
+        const hash = await hashPassword(password);
+        // As setup does: a new user signs every device out.
+        store.update((s) => {
+            s.user = { username, hash };
+            s.logins = [];
+        });
+        return { username };
+    });
+    app.post('/api/setup/address', async (req) => {
+        const body = req.body ?? {};
+        let config;
+        let chosen;
+        if (body.kind === 'tailscale') {
+            const tailscale = (await d.probe()).tailscale;
+            if (!tailscale?.running)
+                throw new Conflict(m.wizard.noTailscale, 'no_tailscale');
+            config = configFor(d.home, `https://${tailscale.dnsName}`);
+            const r = await d.run('tailscale', ['serve', '--bg', String(config.port)]);
+            if (r.code !== 0)
+                throw new DomainError(502, m.wizard.tailscaleFailed(r.out.trim()));
+        }
+        else if (body.kind === 'cloudflare') {
+            const tunnels = (await d.probe()).cloudflared?.tunnels ?? [];
+            if (typeof body.tunnel !== 'string' || !tunnels.includes(body.tunnel))
+                throw new InvalidRequest(m.wizard.noTunnel(String(body.tunnel)));
+            if (typeof body.hostname !== 'string' || !HOSTNAME.test(body.hostname))
+                throw new InvalidRequest(m.wizard.badHostname);
+            config = configFor(d.home, `https://${body.hostname.toLowerCase()}`);
+            chosen = body.tunnel;
+        }
+        else if (body.kind === 'other') {
+            if (typeof body.origin !== 'string')
+                throw new InvalidRequest(m.config.origin);
+            config = configFor(d.home, body.origin.trim().replace(/\/+$/, ''));
+        }
+        else {
+            throw new InvalidRequest('kind: tailscale, cloudflare or other');
+        }
+        writeConfig(d.home, config);
+        tunnel = chosen;
+        return { origin: config.origin };
+    });
+    app.post('/api/setup/service', async () => {
+        if (!store.get().user || !configNow(d.home))
+            throw new Conflict(m.wizard.notReady, 'not_ready');
+        return d.install(tunnel ? { tunnel } : {});
+    });
+    app.post('/api/setup/done', async () => {
+        d.onDone();
+        return {};
+    });
+    // The web app's build, its index.html for /setup; nothing else of the app is reachable without its server.
+    if (existsSync(join(d.webDir, 'index.html'))) {
+        await app.register(fastifyStatic, { root: d.webDir, index: false, wildcard: false });
+        app.get('/setup', (_req, reply) => reply.type('text/html; charset=utf-8').sendFile('index.html'));
+    }
+    app.setNotFoundHandler((_req, reply) => reply.code(404).send({ error: 'not found' }));
+    return app;
+}