workoffdesk 1.0.1 → 1.0.2

package/dist/server/sessions/machine/takeOvers.js

@@ -0,0 +1,92 @@
+import { InvalidRequest } from '../../system/errors.js';
+// How often a conversation waited on is looked at on the Mac, and for how long at most.
+const TAKE_OVER_LOOK_MS = 2_000;
+const TAKE_OVER_WAIT_MS = 12 * 3600_000;
+// The step a take-over waits for is done once the conversation is open nowhere, or its turn is over there.
+const stepDone = (s) => !s || s === 'idle' || s === 'background';
+// Conversations open in a terminal on the Mac, to be taken over once the step there is done. Each is kept in the
+// store while it is waited on, so a server started again goes on waiting for it.
+export class TakeOvers {
+    s;
+    d;
+    p;
+    // Per conversation waited on, the way to stop waiting.
+    waits = new Map();
+    constructor(s, d, p) {
+        this.s = s;
+        this.d = d;
+        this.p = p;
+    }
+    // Those the store has, waited on again; one waited on past its time is let go.
+    resume() {
+        for (const [sid, w] of Object.entries(this.d.store.get().takeOvers ?? {})) {
+            if (Date.now() > w.until)
+                this.forget(sid);
+            else
+                this.wait({ kind: w.kind, cwd: w.cwd, resumeId: sid, title: w.title }, w.until);
+        }
+    }
+    async whenIdle(spec) {
+        if (this.waits.has(spec.resumeId))
+            return null;
+        if (stepDone(await this.onMacStatus(spec)))
+            return this.p.lifecycle.createSession(takenOver(spec));
+        const until = Date.now() + TAKE_OVER_WAIT_MS;
+        this.d.store.update((st) => {
+            st.takeOvers = { ...st.takeOvers, [spec.resumeId]: { kind: spec.kind, cwd: spec.cwd, title: spec.title, until } };
+        });
+        this.wait(spec, until);
+        return null;
+    }
+    waiting(sid) {
+        return this.waits.has(sid);
+    }
+    cancel(sid) {
+        const done = this.waits.get(sid);
+        done?.();
+        return !!done;
+    }
+    wait(spec, until) {
+        const sid = spec.resumeId;
+        let stop;
+        const done = () => {
+            stop();
+            this.waits.delete(sid);
+            this.forget(sid);
+            this.s.emit();
+        };
+        const look = async () => {
+            const now = await this.onMacStatus(spec).catch(() => 'busy');
+            if (this.waits.get(sid) !== done)
+                return;
+            if (!stepDone(now)) {
+                if (Date.now() > until)
+                    return done();
+                stop = this.s.later(TAKE_OVER_LOOK_MS, () => void look());
+                return;
+            }
+            done();
+            await this.p.lifecycle.createSession(takenOver(spec)).catch((e) => console.error(`workoffdesk: conversation ${sid} could not be taken over from the Mac: ${e instanceof Error ? e.message : String(e)}`));
+        };
+        this.waits.set(sid, done);
+        stop = this.s.later(TAKE_OVER_LOOK_MS, () => void look());
+        this.s.emit();
+    }
+    forget(sid) {
+        if (!this.d.store.get().takeOvers?.[sid])
+            return;
+        this.d.store.update((st) => {
+            delete st.takeOvers?.[sid];
+        });
+    }
+    // What a conversation is doing in a terminal on the Mac: undefined when it is open in none.
+    async onMacStatus(spec) {
+        if (spec.kind === 'claude')
+            return (await this.p.lifecycle.openOnMac()).get(spec.resumeId)?.status;
+        if (!this.d.codexThreads)
+            throw new InvalidRequest('Codex is not set up on this Mac');
+        const t = await this.d.codexThreads.where(spec.resumeId);
+        return t?.holder?.at === 'terminal' ? (t.busy ? 'busy' : 'idle') : undefined;
+    }
+}
+const takenOver = (spec) => spec.kind === 'claude' ? { ...spec, kind: 'claude', takeOver: true } : { ...spec, kind: 'codex', takeOver: true };

package/dist/server/sessions/machine.js

@@ -6,12 +6,15 @@ import { CodexThreads } from '../agents/codex/threads.js';
 import { sqliteAvailable } from '../journal/db.js';
 import { Journal } from '../journal/index.js';
 import { Conflict, InvalidRequest } from '../system/errors.js';
+import { projectOf } from '../system/project.js';
 import { shownTitle } from '../system/store.js';
 import { Accounts } from './machine/accounts.js';
 import { Moves } from './machine/moves.js';
+import { Naming } from './machine/naming.js';
+import { TakeOvers } from './machine/takeOvers.js';
 import { Input } from './machine/input.js';
 import { Lifecycle } from './machine/lifecycle.js';
-import { CHAT_SIZE, ID, MachineState, UUID, codexOf } from './machine/state.js';
+import { CHAT_SIZE, ID, MachineState, UUID, codexOf, conversationOf } from './machine/state.js';
 import { Status } from './machine/status.js';
 import { Outbox, migrateQueueFile } from './outbox.js';
 import { idOfTmuxName, tmuxName } from './sessionName.js';
@@ -35,6 +38,8 @@ export class LocalMachine {
     // Per session, the last message still being taken in.
     sending = new Map();
     lastIds = '';
+    // When something last happened in each running session, as the last listing saw it.
+    seen = new Map();
     constructor(deps) {
         const claude = new ClaudeScreen(deps.tmux, CHAT_SIZE.cols);
         if (!sqliteAvailable())
@@ -47,11 +52,11 @@ export class LocalMachine {
             titled: (id, found, fresh) => this.p.lifecycle.conversationNamed(id, found, fresh),
         });
         migrateQueueFile(deps.queueFile ?? join(dirname(deps.store.file), 'queue.json'), this.journal);
+        const log = deps.journal?.log ?? (() => { });
         const outbox = new Outbox({
             store: this.journal,
             status: (id) => this.getStatus(id),
-            // Claude is at work on it from the moment it goes in: the next waits until it is done, not until a
-            // hook says it started.
+            // Claude is at work on it from when it goes in, the next waiting until it is done, not on a hook.
             deliver: async (id, text, qid) => {
                 if (deps.store.get().sessions[id]?.kind === 'codex')
                     return codexOf(this.d).send(id, text, qid);
@@ -65,15 +70,18 @@ export class LocalMachine {
                     this.setStatus(id, 'working');
             },
             changed: () => this.s.emit(),
+            held: (id, qid, why) => log('message held', { session: id, qid, why: why instanceof Error ? why.constructor.name : why }),
             failed: (id, e) => e instanceof DialogOpen || e instanceof AgentQuit || console.error(`workoffdesk: a message to session ${id} could not go and waits: ${e instanceof Error ? e.message : String(e)}`),
         });
         const shell = deps.shell ?? process.env.SHELL ?? '/bin/zsh';
-        const log = deps.journal?.log ?? (() => { });
         const codex = deps.codex
             ? new CodexAgent({ tmux: deps.tmux, sock: deps.codex.sock, codexBin: deps.codex.bin, shell }, {
                 journal: this.journal,
                 sessions: () => Object.entries(deps.store.get().sessions).flatMap(([id, m]) => (m.kind === 'codex' ? [{ id, cwd: m.cwd, createdAt: m.createdAt, threadId: m.codexThreadId }] : [])),
-                setThread: (id, threadId) => deps.store.update((st) => void (st.sessions[id] && (st.sessions[id].codexThreadId = threadId))),
+                setThread: (id, threadId) => {
+                    deps.store.update((st) => void (st.sessions[id] && (st.sessions[id].codexThreadId = threadId)));
+                    this.p.naming.watch();
+                },
                 moved: (id, status, said) => this.p.status.moved(id, status, said),
                 named: (id, name) => this.p.lifecycle.conversationNamed(id, { ai: name }, false),
                 setUsage: (id, usage) => this.setUsage(id, usage),
@@ -107,11 +115,17 @@ export class LocalMachine {
         p.status = new Status(this.s, this.d, p);
         p.accounts = new Accounts(this.d, p);
         p.moves = new Moves(this.s, this.d, p);
+        p.naming = new Naming(this.s, this.d, p);
+        p.takeOvers = new TakeOvers(this.s, this.d, p);
         this.p = p;
+        p.naming.watch();
+        p.takeOvers.resume();
     }
-    async codexOnMac() {
-        return this.d.codexThreads ? this.d.codexThreads.list() : [];
-    }
+    codexOnMac = async () => (this.d.codexThreads ? this.d.codexThreads.list() : []);
+    // Every Codex thread people opened on the Mac, however old.
+    allCodexOnMac = async () => (this.d.codexThreads ? this.d.codexThreads.all() : []);
+    // One Codex thread, however old; null when there is none.
+    oneCodexOnMac = async (id) => (this.d.codexThreads ? this.d.codexThreads.where(id).catch(() => null) : null);
     codexChat(threadId) {
         if (!UUID.test(threadId))
             throw new InvalidRequest('thread id must be a uuid');
@@ -157,10 +171,8 @@ export class LocalMachine {
         });
         const liveIds = new Set(live.map((t) => t.id));
         const stale = known.filter((id) => !liveIds.has(id));
-        if (stale.length) {
-            this.d.store.update((st) => stale.forEach((id) => delete st.sessions[id]));
-            stale.forEach((id) => this.p.status.forget(id));
-        }
+        if (stale.length)
+            this.leave(stale);
         const sessions = live.map(({ id, ...t }) => {
             const meta = this.d.store.get().sessions[id] ?? {
                 title: t.name,
@@ -179,12 +191,50 @@ export class LocalMachine {
         for (const s of sessions)
             if (s.meta.kind === 'codex')
                 this.p.status.lookCodex(s.id, s.meta);
-        const ids = [...liveIds].sort().join(',');
+        for (const s of sessions)
+            this.seen.set(s.id, s.activity);
+        const past = this.d.store.get().past;
+        const ids = `${[...liveIds].sort().join(',')}|${Object.keys(past).sort().join(',')}`;
         if (ids !== this.lastIds) {
             this.lastIds = ids;
             this.s.emit();
         }
-        return sessions.map((s) => this.toSession(s.id, s.meta, s.activity)).sort((a, b) => b.lastActivity - a.lastActivity);
+        const running = sessions.map((s) => this.toSession(s.id, s.meta, s.activity));
+        const held = new Set(running.flatMap((s) => conversationOf(s) ?? []));
+        const kept = Object.entries(past).flatMap(([id, p]) => (held.has(conversationOf(p) ?? '') ? [] : [this.toPast(id, p)]));
+        return [...running, ...kept].sort((a, b) => b.lastActivity - a.lastActivity);
+    }
+    // Sessions tmux no longer has. A Claude or Codex one is kept as past, with its journal, unless a past one of
+    // the same conversation has more of it; a shell one is dropped.
+    leave(ids) {
+        const dropped = [];
+        this.d.store.update((st) => {
+            for (const id of ids) {
+                const meta = st.sessions[id];
+                delete st.sessions[id];
+                const conv = meta && conversationOf(meta);
+                const other = conv ? Object.keys(st.past).find((p) => conversationOf(st.past[p]) === conv) : undefined;
+                if (!meta || meta.kind === 'shell' || (other && this.journal.itemCount(other) > this.journal.itemCount(id))) {
+                    dropped.push(id);
+                    continue;
+                }
+                if (other) {
+                    delete st.past[other];
+                    dropped.push(other);
+                }
+                st.past[id] = { ...meta, lastActivity: this.seen.get(id) ?? meta.createdAt };
+            }
+        });
+        for (const id of ids) {
+            this.p.status.forget(id);
+            this.seen.delete(id);
+        }
+        for (const id of dropped)
+            this.journal.drop(id);
+    }
+    // Gone from tmux and kept to read.
+    isPast(id) {
+        return Object.hasOwn(this.d.store.get().past, id);
     }
     async exists(id) {
         return ID.test(id) && this.d.tmux.hasSession(tmuxName(id));
@@ -209,9 +259,7 @@ export class LocalMachine {
         });
         return taken;
     }
-    unsend(id, queuedId) {
-        return this.d.outbox.remove(id, queuedId);
-    }
+    unsend(id, queuedId) { return this.d.outbox.remove(id, queuedId); }
     async sendNow(id, queuedId) {
         if (!ID.test(id))
             throw new InvalidRequest('bad session id');
@@ -219,17 +267,18 @@ export class LocalMachine {
             throw new Conflict('a dialog is open; pick an option or press Esc first', 'dialog-open');
         return this.d.outbox.sendNow(id, queuedId);
     }
-    moveQueued(id, queuedId, by) {
-        return this.d.outbox.move(id, queuedId, by);
-    }
+    moveQueued(id, queuedId, by) { return this.d.outbox.move(id, queuedId, by); }
     createSession(spec) { return this.p.lifecycle.createSession(spec); }
     continueSession(id) { return this.p.lifecycle.continueSession(id); }
-    openOnMac() { return this.p.lifecycle.openOnMac(); }
-    takeOverWhenIdle(spec) { return this.p.lifecycle.takeOverWhenIdle(spec); }
+    openOnMac(recentMs) { return this.p.lifecycle.openOnMac(recentMs); }
+    macClaudeOf(pid) { return this.p.lifecycle.macClaudeOf(pid); }
+    quitOnMac(id, force) { return this.p.lifecycle.quitOthersOnMac(id, force); }
+    takeOverWhenIdle(spec) { return this.p.takeOvers.whenIdle(spec); }
     takingOver(claudeSessionId) { return this.p.lifecycle.takingOver(claudeSessionId); }
-    cancelTakeOver(claudeSessionId) { return this.p.lifecycle.cancelTakeOver(claudeSessionId); }
+    cancelTakeOver(claudeSessionId) { return this.p.takeOvers.cancel(claudeSessionId); }
     killSession(id) { return this.p.lifecycle.killSession(id); }
     renameSession(id, title) { return this.p.lifecycle.renameSession(id, title); }
+    pinSession(id, on) { return this.p.lifecycle.pinSession(id, on); }
     claudeName(claudeSessionId) { return this.p.lifecycle.claudeName(claudeSessionId); }
     choices(id) { return this.p.input.choices(id); }
     onScreen(id) { return this.p.input.onScreen(id); }
@@ -241,6 +290,7 @@ export class LocalMachine {
     type(id, text) { return this.p.input.type(id, text); }
     close(id) { return this.p.input.close(id); }
     press(id, keys) { return this.p.input.press(id, keys); }
+    toBackground(id) { return this.p.input.toBackground(id); }
     runCommand(id, command) { return this.p.input.runCommand(id, command); }
     fitForChat(id) { return this.p.input.fitForChat(id); }
     getStatus(id) { return this.p.status.getStatus(id); }
@@ -252,6 +302,7 @@ export class LocalMachine {
     setClaudeSessionId(id, claudeSessionId) { this.p.status.setClaudeSessionId(id, claudeSessionId); }
     claudeAccountsView() { return this.p.accounts.claudeAccountsView(); }
     pickClaudeAccount(id) { return this.p.accounts.pickClaudeAccount(id); }
+    moveThis(id, when) { return this.p.moves.moveThis(id, when); }
     async moveToAccountInUse() {
         await this.p.moves.moveAll();
         return this.p.accounts.claudeAccountsView();
@@ -259,6 +310,13 @@ export class LocalMachine {
     sessionMeta(id) {
         return this.d.store.get().sessions[id];
     }
+    // How many sessions are running a turn or compacting.
+    working() {
+        return Object.keys(this.d.store.get().sessions).filter((id) => {
+            const status = this.getStatus(id);
+            return status === 'working' || status === 'compacting';
+        }).length;
+    }
     onChange(cb) {
         this.s.listeners.add(cb);
         return () => this.s.listeners.delete(cb);
@@ -282,7 +340,12 @@ export class LocalMachine {
             clearTimeout(timer);
         };
     }
+    toPast(id, p) {
+        const { lastActivity, ...meta } = p;
+        return { ...this.toSession(id, meta, lastActivity), status: 'ended', usage: null, claudeAccount: undefined, past: true };
+    }
     toSession(id, meta, lastActivity) {
+        const project = projectOf(meta.cwd);
         return {
             id,
             title: shownTitle(meta),
@@ -295,6 +358,7 @@ export class LocalMachine {
             status: meta.kind === 'shell' ? null : (this.s.statuses.get(id) ?? 'idle'),
             usage: this.s.usages.get(id) ?? null,
             claudeAccount: this.p.accounts.accountLabel(meta),
+            ...(project && { project }), ...(meta.pinned && { pinned: meta.pinned }),
         };
     }
 }

package/dist/server/sessions/outbox.js

@@ -38,6 +38,7 @@ export class Outbox {
     deliver;
     changed;
     failed;
+    held;
     gapMs;
     running = new Map();
     again = new Set();
@@ -49,6 +50,7 @@ export class Outbox {
         this.deliver = deps.deliver;
         this.changed = deps.changed;
         this.failed = deps.failed ?? (() => { });
+        this.held = deps.held ?? (() => { });
         this.gapMs = deps.gapMs ?? GAP_MS;
     }
     list(id) {
@@ -67,9 +69,11 @@ export class Outbox {
         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))) {
+        const status = this.status(id);
+        if (!this.waiting(id).length && !HOLDS.has(status)) {
             return this.pasting(qid, async () => ((await this.paste(id, m)) ? null : (this.put(id, { ...m, ord: this.lastOrd(id) + 1 }), queued(m))));
         }
+        this.held(id, qid, HOLDS.has(status) ? status : 'behind');
         this.put(id, { ...m, ord: this.lastOrd(id) + 1 });
         void this.flush(id);
         return queued(m);
@@ -163,6 +167,8 @@ export class Outbox {
         catch (e) {
             this.failed(id, e);
             went = mayHaveRun(e);
+            if (!went)
+                this.held(id, m.id, 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')

package/dist/server/system/config.js

@@ -38,6 +38,10 @@ export function parseConfig(raw) {
     if (typeof rpId !== 'string' || !(url.hostname === rpId || url.hostname.endsWith(`.${rpId}`))) {
         throw new ConfigError('rpId', m.config.rpId(url.hostname));
     }
+    const extra = r.extraOrigins ?? [];
+    if (!isStrings(extra) || !extra.every((o) => originUrl(o)?.protocol === 'https:'))
+        throw new ConfigError('extraOrigins', m.config.extraOrigins);
+    const extraOrigins = [...new Set(extra)].filter((o) => o !== url.origin);
     const pinnedDirs = r.pinnedDirs ?? [];
     if (!isStrings(pinnedDirs))
         throw new ConfigError('pinnedDirs', m.config.pinnedDirs);
@@ -51,7 +55,18 @@ export function parseConfig(raw) {
     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 };
+    return { port, origin: url.origin, extraOrigins, rpId, pinnedDirs, serviceLabel, claudeArgs, preventSleep };
+}
+// The origin first. Another address shares the rpId when its host is under it; else its passkeys are its own.
+export function sites(c) {
+    const under = (host) => host === c.rpId || host.endsWith(`.${c.rpId}`);
+    return [
+        { origin: c.origin, rpId: c.rpId },
+        ...c.extraOrigins.map((origin) => {
+            const host = new URL(origin).hostname;
+            return { origin, rpId: under(host) ? c.rpId : host };
+        }),
+    ];
 }
 export function loadConfig(home) {
     const file = join(home, 'config.json');

package/dist/server/system/errors.js

@@ -16,8 +16,8 @@ export class InvalidRequest extends DomainError {
     }
 }
 export class NotFound extends DomainError {
-    constructor(message) {
-        super(404, message);
+    constructor(message, code) {
+        super(404, message, code);
     }
 }
 export class Conflict extends DomainError {

package/dist/server/system/messages.js

@@ -1,5 +1,7 @@
 // What the CLI says to the person at the Mac: Chinese when the Mac speaks it, English otherwise.
 // The phone has its own dictionary (@workoffdesk/i18n); errors the server sends it go by code, not words.
+import { zh } from './messages.zh.js';
+export { zh };
 // The same rule as the phone's.
 export function pickLang(languages) {
     for (const l of languages) {
@@ -35,6 +37,7 @@ export const en = {
             restart: [['restart', 'Restart the service; sessions keep running']],
             doctor: [['doctor', 'Check everything and print the fix for each failure']],
             status: [['status --json', 'The checks, the version, the releases and the newest errors, as JSON']],
+            activity: [['activity --json', 'How many sessions are working: a line of JSON now and at each change']],
             claude: [['claude [--resume <session id>]', 'Start Claude in this folder as a session and join it']],
             codex: [['codex [--resume <thread id>]', 'Start Codex in this folder as a session and join it']],
             attach: [['attach [id]', 'Join a session from this terminal; without an id, pick one']],
@@ -50,6 +53,7 @@ export const en = {
             '--help': [['--help', 'Print this list']],
         },
         statusUsage: 'Usage: workoffdesk status --json (what the menu bar app reads; doctor is the one for people)',
+        activityUsage: 'Usage: workoffdesk activity --json (what the menu bar app reads)',
         notConfigured: (example) => `Not configured yet. Tell setup the address the site is reached at:\n  workoffdesk setup --origin ${example}`,
         askOrigin: (example) => `The address the site is reached at (the one the phone opens, like ${example}): `,
         askUsername: 'Username: ',
@@ -116,7 +120,7 @@ To restart the service only: launchctl kickstart -k gui/$(id -u)/${o.label}`,
         sleepsOff: 'preventSleep is false: when the Mac idle-sleeps, the phone cannot reach it until someone wakes it',
         sleepFix: (file) => `Remove "preventSleep": false from ${file}, then restart the service.`,
         awake: 'the Mac does not idle-sleep while the service runs',
-        noApns: 'no push key: the iPhone app gets no notifications; web push works without it',
+        noApns: "no push key: an iPhone app you build yourself gets no notifications; the App Store app's come through its relay, and web push works without it",
         apnsKey: (keyId) => `push key ${keyId}`,
         apnsFix: (file) => `Fix ${file}, or remove it if you do not use the iPhone app.`,
         failed: 'Some checks failed; each ✗ says what to do.',
@@ -150,6 +154,7 @@ To restart the service only: launchctl kickstart -k gui/$(id -u)/${o.label}`,
         pinnedDirs: 'an array of folder paths',
         serviceLabel: 'a launchd label of letters, digits, dots and hyphens',
         claudeArgs: 'an array of arguments claude is started with, like ["--chrome"]',
+        extraOrigins: 'an array of other https addresses the site is also reached at, like ["https://other.example.com"]',
         preventSleep: 'true (keep the Mac from idle-sleeping while the service runs) or false',
         missing: (file) => `set, but ${file} does not exist yet; run workoffdesk setup first`,
         format: 'the format',
@@ -188,6 +193,7 @@ To restart the service only: launchctl kickstart -k gui/$(id -u)/${o.label}`,
     },
     takeOver: {
         openOnMac: (ttys, agent) => `this conversation is open in a terminal on the Mac${ttys.some(Boolean) ? ` (${ttys.filter(Boolean).join(', ')})` : ''}; quit ${agent} there first, or take it over from the phone`,
+        macUnanswered: 'The Mac did not say in time whether this conversation is open in a terminal there; try again in a moment',
         wouldNotQuit: (agent) => `${agent} in the terminal on the Mac did not quit within 10 seconds; nothing was resumed`,
         openElsewhere: 'this conversation is open in another Codex app (an editor or the Codex app); close it there first',
         // Said in the terminal it was quit in.
@@ -196,183 +202,15 @@ To restart the service only: launchctl kickstart -k gui/$(id -u)/${o.label}`,
     goOn: {
         onlyClaude: 'only a Claude session whose Claude quit is gone on with in place',
         terminalBusy: "something runs in this session's terminal on the Mac; quit it there first, or start another conversation",
+        conversationGone: (agent) => `${agent} no longer keeps this conversation, so it cannot be gone on with; what was said can still be read here`,
     },
-    folderGone: (path) => `its folder is gone: ${path}`,
-};
-export const zh = {
-    cli: {
-        usage: '用法：workoffdesk <命令>',
-        unknownCommand: (cmd) => `没有 ${cmd} 这个命令。`,
-        help: {
-            setup: [
-                ['setup', '设用户名和密码；再跑一次会换新密码，所有设备都要重新登录'],
-                ['setup --web', '在浏览器里做设置，包括地址和服务'],
-            ],
-            install: [['install [--tunnel <名字>]', '写好 launchd 服务（不启动），并打印接下来要跑的命令']],
-            start: [['start', '启动服务，等它应答']],
-            stop: [['stop', '停掉服务，直到下次登录或 start']],
-            restart: [['restart', '重启服务；会话继续跑']],
-            doctor: [['doctor', '检查所有项，每项没过都给出修复方法']],
-            status: [['status --json', '以 JSON 输出检查结果、版本、保留的各版本和最近的错误']],
-            claude: [['claude [--resume <会话 id>]', '在当前目录开一个 Claude 会话并接上']],
-            codex: [['codex [--resume <对话 id>]', '在当前目录开一个 Codex 会话并接上']],
-            attach: [['attach [id]', '在当前终端接上一个会话；不给 id 就让你挑']],
-            account: [
-                ['account [--json]', '这台 Mac 上的 Claude 账号，以及新会话用哪一个'],
-                ['account use <邮箱或目录> [--move]', '新会话改用它；加 --move 把开着的会话也搬过去'],
-                ['account move', '把开着的会话搬到正在用的账号，每个等它这轮回复完再搬'],
-            ],
-            serve: [['serve', '在当前终端里跑服务器，而不是作为后台服务']],
-            deploy: [['deploy <构建目录>', '把一个构建装成新版本并切过去']],
-            rollback: [['rollback', '回到上一个版本']],
-            '--version': [['--version', '打印装的版本']],
-            '--help': [['--help', '打印这张列表']],
-        },
-        statusUsage: '用法：workoffdesk status --json（给菜单栏 App 读的；给人看用 doctor）',
-        notConfigured: (example) => `还没有配置。告诉 setup 这个站点的访问地址：\n  workoffdesk setup --origin ${example}`,
-        askOrigin: (example) => `站点的访问地址（手机打开的那个，比如 ${example}）：`,
-        askUsername: '用户名：',
-        emptyUsername: '用户名不能为空',
-        askPassword: (min) => `密码（至少 ${min} 个字符）：`,
-        askAgain: '再输一次：',
-        passwordsDiffer: '两次输入的密码不一致',
-        passwordTooShort: (min) => `密码至少要 ${min} 个字符`,
-        setUp: (username, origin, configFile, port) => `用户 ${username} 已设置好，地址 ${origin}。配置：${configFile}
-
-下一步：
-  workoffdesk serve      先在本机试一下（http://127.0.0.1:${port}）
-  workoffdesk install    装成登录时自动启动的服务，并看看怎么在前面接隧道或反向代理
-开放到公网之前，先读 SECURITY.md：谁进得了这个站点，谁就拿到了这台电脑的终端。`,
-        notSetUp: '还没有设置用户。运行：workoffdesk setup',
-        scan: (origin) => `用手机相机扫一下，打开 ${origin}：`,
-        running: (port, origin) => `workoffdesk 正在 http://127.0.0.1:${port} 上运行，访问地址 ${origin}`,
-        noSessions: '没有会话。',
-        whichOne: '选哪一个？',
-        noSuchNumber: '没有这个编号',
-        notRunning: 'WorkOffDesk 服务没有在运行。先启动它（workoffdesk serve，或已安装的服务）。',
-        couldNotOpen: (why) => `打不开会话：${why}`,
-        noTunnel: (name) => `没有叫 ${name} 的隧道。运行：\n  cloudflared tunnel create ${name}\n然后再运行一次 workoffdesk install --tunnel ${name}。`,
-        noCloudflared: '找不到 cloudflared。先运行 brew install cloudflared。',
-        notBuilt: (cliPath) => `注意：${cliPath} 还不存在，先构建（pnpm build）。`,
-        noCredentials: (file) => `注意：隧道凭据 ${file} 不在这台电脑上；请在创建这条隧道的电脑上运行它。`,
-        frontDoor: (port, origin) => `服务只监听 http://127.0.0.1:${port}。需要在它前面放一个能把 ${origin} 转到这里的东西：
-  Cloudflare 隧道：cloudflared tunnel create <名字>，然后 workoffdesk install --tunnel <名字>
-  或任何反向代理（Caddy、nginx…），把 ${origin} 转发到 http://127.0.0.1:${port}，并支持 WebSocket`,
-        installed: (o) => `node：${o.nodePath}（换了 node 版本之后，用 --node <路径> 再运行一次 install）
-已写入：
-${o.written.map((f) => `  ${f}`).join('\n')}
-${o.warnings.length ? `\n${o.warnings.join('\n')}\n` : ''}
-现在要运行的命令（只需第一次）：
-${o.frontDoor}
-
-以后更新：workoffdesk deploy <构建目录>；需要时 workoffdesk rollback。
-只重启服务：launchctl kickstart -k gui/$(id -u)/${o.label}`,
-        deployUsage: '用法：workoffdesk deploy <构建目录> [--new-app-runtime]（构建目录是 pnpm deploy --prod 生成的那个）',
-    },
-    doctor: {
-        notFound: '找不到',
-        unknownVersion: (version) => `看不出版本（${version}）`,
-        tooOld: (version, min) => `${version}；需要 ${min} 或更高`,
-        macosOnly: '服务只支持 macOS（它用 launchd，管的是这台 Mac 上的 Claude Code 会话）。',
-        nodeFix: (min) => `装 node ${min} 或更高版本（brew install node，或 nvm install 22），然后再运行一次 workoffdesk install。`,
-        tmuxFix: 'brew install tmux',
-        claudeFix: '安装 Claude Code：curl -fsSL https://claude.ai/install.sh | bash',
-        noCodex: '没有安装（可选：用来开 Codex 会话）',
-        setupFix: 'workoffdesk setup',
-        setUp: (user, origin) => `用户 ${user}，地址 ${origin}`,
-        notSetUp: (home) => `还没有设置（${home} 里没有 config.json）`,
-        noUser: '还没有设置用户',
-        running: (local, version) => `在 ${local} 上运行${version ? `，版本 ${version}` : ''}`,
-        notAnswering: (local) => `${local} 上没有回应`,
-        otherVersion: (local, running, mine) => `${local} 上跑的是 ${running}，这个命令是 ${mine}`,
-        restartFix: (label) => `重启它：launchctl kickstart -k gui/$(id -u)/${label}`,
-        installFix: '把它装成服务:workoffdesk install,再执行它打印的那行 launchctl bootstrap(或者用 workoffdesk serve 先试)',
-        bootstrapFix: (plist) => `启动它:launchctl bootstrap gui/$(id -u) ${plist}`,
-        kickstartFix: (label, log) => `重启它:launchctl kickstart -k gui/$(id -u)/${label};如果又停了，原因在 ${log}`,
-        localOnly: (origin) => `${origin}：只有这台 Mac 能访问`,
-        notReached: (origin) => `${origin} 到不了服务`,
-        originFix: (origin, local) => `检查把 ${origin} 转到 ${local} 的隧道或反向代理。`,
-        sleepsOff: 'preventSleep 是 false：Mac 空闲睡眠之后，手机就连不上，直到有人把它叫醒',
-        sleepFix: (file) => `把 ${file} 里的 "preventSleep": false 删掉，然后重启服务。`,
-        awake: '服务运行时 Mac 不会空闲睡眠',
-        noApns: '没有推送密钥：iPhone App 收不到通知；网页推送不受影响',
-        apnsKey: (keyId) => `推送密钥 ${keyId}`,
-        apnsFix: (file) => `改好 ${file}；不用 iPhone App 的话删掉它。`,
-        failed: '有检查没通过；每个 ✗ 下面写了怎么办。',
+    moveThis: {
+        cannot: 'only a Claude session here whose Claude runs, in a folder still there, moves to another account',
+        busy: 'it moves once Claude is at its prompt with nothing waiting to go in; try again when its reply is done',
+        macBusy: 'this conversation is also open in a terminal on the Mac, where Claude is at work or asking something; let it finish there first',
+        failed: (why) => `it stays on its account: ${why}`,
     },
-    ops: {
-        started: (port) => `服务已在 http://127.0.0.1:${port} 运行`,
-        stopped: '服务已停止；下次登录时会再启动，或运行 workoffdesk start',
-        restarted: '服务已重启',
-        notUp: (log) => `服务 30 秒内没有应答；原因多半在 ${log}`,
-    },
-    wizard: {
-        open: (url) => `接下来在浏览器里设置。如果没有自动打开，在这台 Mac 上打开这个地址：\n  ${url}\n按 Ctrl-C 结束。`,
-        idle: '设置页 30 分钟没人用，已经结束。再运行 workoffdesk setup --web 重新开始。',
-        done: '设置完成。',
-        notReady: '先设好账号和地址',
-        noTailscale: '这台 Mac 上的 Tailscale 没有运行',
-        tailscaleFailed: (out) => `tailscale serve 失败：${out}`,
-        noTunnel: (name) => `这台 Mac 上没有叫 ${name} 的 Cloudflare 隧道`,
-        badHostname: '主机名是 workoffdesk.example.com 这样的名字，不带 https:// 也不带路径',
-        routeFailed: (out) => `cloudflared 没能把主机名指到隧道：${out}`,
-    },
-    node: {
-        doesNotRun: (node) => `${node} 运行不了。`,
-        tooOld: (node, version, min) => `${node} 是 ${version}；WorkOffDesk 需要 node ${min} 或更高版本。`,
-    },
-    config: {
-        wrong: (field, expected) => `config.json：${field} 不对，应该是${expected}`,
-        origin: '站点的访问地址，比如 https://workoffdesk.example.com（在本机试用就用 http://localhost:<端口>）',
-        port: '1 到 65535 之间的整数',
-        rpId: (hostname) => `站点的主机名（${hostname}）或它的上级域名`,
-        pinnedDirs: '文件夹路径的数组',
-        serviceLabel: '由字母、数字、点和连字符组成的 launchd 标签',
-        claudeArgs: '启动 claude 时带的参数数组，比如 ["--chrome"]',
-        preventSleep: 'true（服务运行时不让 Mac 空闲睡眠）或 false',
-        missing: (file) => `已设置的，但 ${file} 还不存在；先运行 workoffdesk setup`,
-        format: '格式',
-        notJson: (why) => `合法的 JSON（${why}）`,
-    },
-    release: {
-        notABuild: (dir) => `${dir} 不是一个构建（需要有 package.json 和 dist/server/cli.js）`,
-        smokeFailed: (version) => `${version} 没通过冒烟测试；正在运行的版本没动`,
-        didNotComeUp: (version, prev) => `${version} 30 秒内没有起来；${prev ? `已切回 ${prev}` : '没有更早的版本可以切回'}`,
-        staleBuild: (version, built) => `这个构建写的是 ${version}，但它的 dist ${built ? `是为 ${built} 构建的` : '不是一次完整构建产出的'}；重新运行 pnpm build`,
-        deployed: (version, name) => `已部署 ${version}（${name}）`,
-        builtFrom: (s) => (s.commit ? `构建自 ${s.commit.slice(0, 12)}${s.dirty ? '，带未提交的改动' : ''}` : '不是在 git 里构建的'),
-        appUpdate: (runtime) => (runtime ? `iPhone 应用更新，运行时 ${runtime}` : '这个构建没有 iPhone 应用更新'),
-        appRuntimeChanged: (live, built) => `线上的 iPhone 应用更新是给运行时 ${live} 的，这个构建的${built ? `却是给 ${built} 的` : '没有（设了 WORKOFFDESK_IOS_BUNDLE_ID 吗？）'}，装着 ${live} 的手机就再也收不到更新。App 的 JavaScript 以外的改动（它的 package.json 或 app 配置）会改变运行时。只有 App 的新版本发出去以后，才用 --new-app-runtime 部署`,
-        nothingToRollBackTo: '没有更早的版本可以回滚',
-        rollbackFailed: (target, current) => `${target} 没有起来；已切回 ${current}`,
-        rolledBack: (version, name) => `已回滚到 ${version}（${name}）`,
-    },
-    account: {
-        usage: '用法：workoffdesk account [--json] | account use <邮箱或目录> [--move] | account move',
-        signedOut: '已退出登录',
-        notReady: '先在终端里用它打开一次 Claude Code',
-        apart: '它的对话没有和这台 Mac 的共用',
-        notSeen: '还没看到它的用量',
-        fiveHour: (p) => `5 小时 ${p}`,
-        sevenDay: (p) => `7 天 ${p}`,
-        reset: '已重置',
-        elsewhere: (n) => `${n} 个开着的会话在别的账号上。搬过来：workoffdesk account move`,
-        moving: (n) => `${n} 个会话等这轮回复完就搬过来。`,
-        noSuch: (who) => `这台 Mac 上没有 ${who} 这个 Claude 账号。`,
-        twoWithEmail: (email, folders) => `不止一个账号是 ${email}，改用目录指定：${folders.join('、')}`,
-        nonePicked: '还没有选过账号。先选一个：workoffdesk account use <邮箱或目录>',
-    },
-    takeOver: {
-        openOnMac: (ttys, agent) => `这个对话正开在 Mac 的终端里${ttys.some(Boolean) ? `（${ttys.filter(Boolean).join('、')}）` : ''}；先在那里退出 ${agent}，或者从手机上接管`,
-        wouldNotQuit: (agent) => `Mac 终端里的 ${agent} 10 秒内没有退出；没有续上`,
-        openElsewhere: '这个对话开在别的 Codex 应用里（编辑器或 Codex 桌面版）；先在那里关掉',
-        goneToPhone: (id) => `workoffdesk：这个对话已转到 workoffdesk 里接着进行。要在这台电脑上接着用：workoffdesk attach ${id}`,
-    },
-    goOn: {
-        onlyClaude: '只有 Claude 已退出的 Claude 会话能原地接着',
-        terminalBusy: '这个会话在 Mac 的终端里正跑着别的程序；先在那里退出它，或者重新开一个对话',
-    },
-    folderGone: (path) => `它的文件夹已经不在了：${path}`,
+    folderGone: (path) => `its folder is gone: ${path}`,
 };
 export const messagesFor = (languages) => (pickLang(languages) === 'zh' ? zh : en);
 export const m = messagesFor(systemLanguages());