@prohost/cli 0.15.0 → 0.16.1

package/dist/host/session_move.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Move a conversation's session from one AI login to another of the same kind.
+ *
+ * Used only when sharing between logins is on for this computer and the
+ * conversation's login rests (its usage limit). The session file is copied —
+ * never moved — so the first login keeps its own history, and the run resumes
+ * on the second with a note that it was interrupted.
+ *
+ * - Claude Code keeps a session at `<config dir>/projects/<project>/<id>.jsonl`
+ *   (plus a `<id>/` folder for subagents and large tool results), where
+ *   `<project>` is the working directory with every non-alphanumeric character
+ *   turned into `-`.
+ * - Codex keeps a rollout at `<CODEX_HOME>/sessions/YYYY/MM/DD/rollout-…-<id>.jsonl`.
+ *   A `CODEX_HOME` inside WSL (`wsl://<distro>/home/…`, or the
+ *   `\\wsl.localhost\…` / `\\wsl$\…` share) is reached through the share.
+ *
+ * Claude and Codex are never mixed: a copy between runtimes is refused.
+ */
+import type { AccountRuntime } from '../agent/accounts.js';
+export declare const INTERRUPTED_NOTE: string;
+export type SessionMoveResult = {
+    ok: true;
+    copied: string[];
+} | {
+    ok: false;
+    reason: string;
+};
+/** Claude Code's project folder name for a working directory. */
+export declare function claudeProjectSlug(cwd: string): string;
+/**
+ * A login directory as this process reaches it. On Windows, a WSL home given
+ * as `wsl://<distro>/<path>` becomes `\\wsl.localhost\<distro>\<path>`; the
+ * share forms are used as they are.
+ */
+export declare function reachableDir(dir: string, platform?: NodeJS.Platform): string;
+export interface SessionMoveRequest {
+    runtime: AccountRuntime;
+    /** Runtime of the login being copied to. Must equal `runtime`. */
+    targetRuntime: AccountRuntime;
+    fromDir: string;
+    toDir: string;
+    sessionId: string;
+    /** The run's working directory (Claude Code names the project after it). */
+    cwd: string;
+    platform?: NodeJS.Platform;
+}
+/** Copy a session so the target login can resume it. Never overwrites the target's newer copy. */
+export declare function copySession(request: SessionMoveRequest): SessionMoveResult;

package/dist/host/session_move.js

@@ -0,0 +1,106 @@
+/**
+ * Move a conversation's session from one AI login to another of the same kind.
+ *
+ * Used only when sharing between logins is on for this computer and the
+ * conversation's login rests (its usage limit). The session file is copied —
+ * never moved — so the first login keeps its own history, and the run resumes
+ * on the second with a note that it was interrupted.
+ *
+ * - Claude Code keeps a session at `<config dir>/projects/<project>/<id>.jsonl`
+ *   (plus a `<id>/` folder for subagents and large tool results), where
+ *   `<project>` is the working directory with every non-alphanumeric character
+ *   turned into `-`.
+ * - Codex keeps a rollout at `<CODEX_HOME>/sessions/YYYY/MM/DD/rollout-…-<id>.jsonl`.
+ *   A `CODEX_HOME` inside WSL (`wsl://<distro>/home/…`, or the
+ *   `\\wsl.localhost\…` / `\\wsl$\…` share) is reached through the share.
+ *
+ * Claude and Codex are never mixed: a copy between runtimes is refused.
+ */
+import { cpSync, existsSync, mkdirSync, readdirSync, statSync } from 'node:fs';
+import path from 'node:path';
+import { findCodexRollout } from '../agent/runtime_status.js';
+export const INTERRUPTED_NOTE = 'Note: you were interrupted partway through this work and are continuing it from another sign-in. ' +
+    "Check what's already done — messages sent, files changed, tasks updated — before doing anything again.";
+/** Claude Code's project folder name for a working directory. */
+export function claudeProjectSlug(cwd) {
+    return cwd.replace(/[^A-Za-z0-9]/g, '-');
+}
+/**
+ * A login directory as this process reaches it. On Windows, a WSL home given
+ * as `wsl://<distro>/<path>` becomes `\\wsl.localhost\<distro>\<path>`; the
+ * share forms are used as they are.
+ */
+export function reachableDir(dir, platform = process.platform) {
+    const match = /^wsl:\/\/([^/]+)(\/.*)$/.exec(dir);
+    if (!match)
+        return dir;
+    if (platform !== 'win32')
+        return match[2];
+    return `\\\\wsl.localhost\\${match[1]}${match[2].replace(/\//g, '\\')}`;
+}
+const SESSION_ID = /^[0-9A-Za-z-]{8,64}$/;
+function isDir(p) {
+    try {
+        return statSync(p).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/** Where a Claude session's file is under one config dir: the expected project first, then any. */
+function findClaudeSession(configDir, sessionId, cwd) {
+    const projects = path.join(configDir, 'projects');
+    const expected = path.join(projects, claudeProjectSlug(cwd), `${sessionId}.jsonl`);
+    if (existsSync(expected))
+        return expected;
+    let names = [];
+    try {
+        names = readdirSync(projects);
+    }
+    catch {
+        return undefined;
+    }
+    for (const name of names) {
+        const candidate = path.join(projects, name, `${sessionId}.jsonl`);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+}
+/** Copy a session so the target login can resume it. Never overwrites the target's newer copy. */
+export function copySession(request) {
+    if (request.runtime !== request.targetRuntime) {
+        return { ok: false, reason: 'Claude Code and Codex sessions never move between each other' };
+    }
+    if (!SESSION_ID.test(request.sessionId))
+        return { ok: false, reason: 'not a session id' };
+    const from = reachableDir(request.fromDir, request.platform);
+    const to = reachableDir(request.toDir, request.platform);
+    if (path.resolve(from) === path.resolve(to))
+        return { ok: false, reason: 'the same login' };
+    if (request.runtime === 'claude_code') {
+        const file = findClaudeSession(from, request.sessionId, request.cwd);
+        if (!file)
+            return { ok: false, reason: 'the session file is not in the first login' };
+        const project = path.basename(path.dirname(file));
+        const targetDir = path.join(to, 'projects', project);
+        mkdirSync(targetDir, { recursive: true, mode: 0o700 });
+        const copied = [path.join(targetDir, `${request.sessionId}.jsonl`)];
+        cpSync(file, copied[0], { force: true });
+        const sidecar = path.join(path.dirname(file), request.sessionId);
+        if (isDir(sidecar)) {
+            const target = path.join(targetDir, request.sessionId);
+            cpSync(sidecar, target, { recursive: true, force: true });
+            copied.push(target);
+        }
+        return { ok: true, copied };
+    }
+    const rollout = findCodexRollout(request.sessionId, { CODEX_HOME: from });
+    if (!rollout)
+        return { ok: false, reason: 'the rollout is not in the first login' };
+    const relative = path.relative(from, rollout);
+    const target = path.join(to, relative);
+    mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
+    cpSync(rollout, target, { force: true });
+    return { ok: true, copied: [target] };
+}

package/dist/host/skills.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Write an employee's skills into its workspace before a run.
+ *
+ * - Claude Code reads project skills from `.claude/skills/<key>/SKILL.md` in
+ *   its working directory.
+ * - Codex reads project instructions from `AGENTS.md`; the skills go to
+ *   `.codex/skills/<key>/` and `AGENTS.md` lists them, so the agent opens the
+ *   one it needs.
+ *
+ * The claim's list is the employee's whole set: a skill the host wrote before
+ * that is no longer granted is removed. Only folders the host wrote (named in
+ * its manifest) are ever removed — anything else in the workspace is left alone.
+ */
+import type { AccountRuntime } from '../agent/accounts.js';
+import type { ClaimedSkill } from './api.js';
+export declare function skillsRoot(workspace: string, runtime: AccountRuntime): string;
+/** A file path inside a skill: relative, no `..`, no absolute or drive paths. */
+export declare function safeSkillPath(relative: string): string | undefined;
+export interface SkillsWritten {
+    written: string[];
+    skipped: Array<{
+        key: string;
+        reason: string;
+    }>;
+    removed: string[];
+}
+/** Replace (or add) the host's block in `AGENTS.md`, keeping anything the operator wrote. */
+export declare function agentsMdWithSkills(existing: string, keys: string[]): string;
+export declare function writeSkills(workspace: string, runtime: AccountRuntime, skills: readonly ClaimedSkill[]): SkillsWritten;

package/dist/host/skills.js

@@ -0,0 +1,135 @@
+/**
+ * Write an employee's skills into its workspace before a run.
+ *
+ * - Claude Code reads project skills from `.claude/skills/<key>/SKILL.md` in
+ *   its working directory.
+ * - Codex reads project instructions from `AGENTS.md`; the skills go to
+ *   `.codex/skills/<key>/` and `AGENTS.md` lists them, so the agent opens the
+ *   one it needs.
+ *
+ * The claim's list is the employee's whole set: a skill the host wrote before
+ * that is no longer granted is removed. Only folders the host wrote (named in
+ * its manifest) are ever removed — anything else in the workspace is left alone.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+const SKILL_KEY = /^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/;
+const MANIFEST = '.prohost-skills.json';
+const AGENTS_BEGIN = '<!-- prohost skills: begin -->';
+const AGENTS_END = '<!-- prohost skills: end -->';
+/** One skill's files may not exceed this in total. */
+const MAX_SKILL_BYTES = 2 * 1024 * 1024;
+export function skillsRoot(workspace, runtime) {
+    return path.join(workspace, runtime === 'claude_code' ? '.claude' : '.codex', 'skills');
+}
+/** A file path inside a skill: relative, no `..`, no absolute or drive paths. */
+export function safeSkillPath(relative) {
+    if (!relative || relative.length > 256 || relative.includes('\0'))
+        return undefined;
+    const normalized = path.posix.normalize(relative.replace(/\\/g, '/'));
+    if (normalized.startsWith('/') || /^[A-Za-z]:/.test(normalized) || normalized === '.')
+        return undefined;
+    if (normalized.split('/').some((part) => part === '..' || part === ''))
+        return undefined;
+    return normalized;
+}
+/** Skill key → digest of what the host last wrote for it. */
+function readManifest(root) {
+    try {
+        const parsed = JSON.parse(readFileSync(path.join(root, MANIFEST), 'utf8'));
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+            return new Map();
+        return new Map(Object.entries(parsed).filter((entry) => SKILL_KEY.test(entry[0]) && typeof entry[1] === 'string'));
+    }
+    catch {
+        return new Map();
+    }
+}
+function digest(files) {
+    const hash = createHash('sha256');
+    for (const file of [...files].sort((a, b) => a.path.localeCompare(b.path))) {
+        hash.update(file.path).update('\0').update(file.content).update('\0');
+    }
+    return hash.digest('hex');
+}
+/** Replace (or add) the host's block in `AGENTS.md`, keeping anything the operator wrote. */
+export function agentsMdWithSkills(existing, keys) {
+    const block = keys.length === 0
+        ? ''
+        : [
+            AGENTS_BEGIN,
+            '## Skills',
+            '',
+            'You have these skills. Before work a skill covers, read its SKILL.md and follow it:',
+            '',
+            ...keys.map((key) => `- ${key}: .codex/skills/${key}/SKILL.md`),
+            AGENTS_END,
+        ].join('\n');
+    const start = existing.indexOf(AGENTS_BEGIN);
+    const end = existing.indexOf(AGENTS_END);
+    const rest = start !== -1 && end > start ? `${existing.slice(0, start)}${existing.slice(end + AGENTS_END.length)}` : existing;
+    const trimmed = rest.trim();
+    if (!block)
+        return trimmed ? `${trimmed}\n` : '';
+    return trimmed ? `${trimmed}\n\n${block}\n` : `${block}\n`;
+}
+export function writeSkills(workspace, runtime, skills) {
+    const root = skillsRoot(workspace, runtime);
+    mkdirSync(root, { recursive: true, mode: 0o700 });
+    const result = { written: [], skipped: [], removed: [] };
+    const previous = readManifest(root);
+    const keep = new Map();
+    for (const skill of skills) {
+        if (!SKILL_KEY.test(skill.key)) {
+            result.skipped.push({ key: skill.key, reason: 'not a usable skill key' });
+            continue;
+        }
+        const files = skill.files.map((file) => ({ path: safeSkillPath(file.path), content: file.content }));
+        const bad = files.find((file) => file.path === undefined);
+        const bytes = skill.files.reduce((sum, file) => sum + Buffer.byteLength(file.content), 0);
+        if (bad || bytes > MAX_SKILL_BYTES) {
+            result.skipped.push({ key: skill.key, reason: bad ? 'a file path leaves the skill folder' : 'too large' });
+            continue;
+        }
+        const dir = path.join(root, skill.key);
+        const sum = digest(files);
+        keep.set(skill.key, sum);
+        // Unchanged since the last run: left as it is, so a run of the same
+        // employee already reading it never sees it half rewritten.
+        if (previous.get(skill.key) === sum && existsSync(dir))
+            continue;
+        rmSync(dir, { recursive: true, force: true });
+        for (const file of files) {
+            const target = path.join(dir, file.path);
+            mkdirSync(path.dirname(target), { recursive: true, mode: 0o700 });
+            writeFileSync(target, file.content, { mode: 0o600 });
+        }
+        result.written.push(skill.key);
+    }
+    for (const key of previous.keys()) {
+        if (keep.has(key))
+            continue;
+        rmSync(path.join(root, key), { recursive: true, force: true });
+        result.removed.push(key);
+    }
+    writeFileSync(path.join(root, MANIFEST), `${JSON.stringify(Object.fromEntries(keep))}\n`, { mode: 0o600 });
+    if (runtime === 'codex') {
+        const agentsMd = path.join(workspace, 'AGENTS.md');
+        let existing = '';
+        try {
+            existing = readFileSync(agentsMd, 'utf8');
+        }
+        catch {
+            existing = '';
+        }
+        const next = agentsMdWithSkills(existing, [...keep.keys()]);
+        if (next !== existing) {
+            if (next)
+                writeFileSync(agentsMd, next, { mode: 0o600 });
+            else
+                rmSync(agentsMd, { force: true });
+        }
+    }
+    return result;
+}

package/dist/host/status.d.ts

@@ -0,0 +1,91 @@
+/**
+ * What the host tells ProhostAI (`POST /v1/computers/{id}/status`), what it
+ * keeps locally for `prohost host status` and the desktop app (`state.json`,
+ * `activity.json`), and the server's answer (the computer's config).
+ *
+ * The status body never carries a login's email or config directory: those
+ * stay in the local files only.
+ */
+import type { AccountRuntime } from '../agent/accounts.js';
+import type { HostStats } from '../codehost/host_stats.js';
+import type { HeldReason } from './capacity.js';
+import type { LoginInfo } from './logins.js';
+export interface Placement {
+    agent_id: string;
+    runtime: AccountRuntime;
+    max_concurrent: number | null;
+    keep_one_ready: boolean;
+}
+export interface ComputerConfig {
+    name?: string;
+    capacity: number | null;
+    recommended_capacity: number | null;
+    hold_on_pressure: boolean;
+    hold_on_battery: boolean;
+    ai_employees_enabled: boolean;
+    terminal_sessions_enabled: boolean;
+    share_logins: Record<AccountRuntime, boolean>;
+    paused: boolean;
+    placements: Placement[];
+}
+export declare const DEFAULT_CONFIG: ComputerConfig;
+/** The status answer's `config`, read defensively over the previous one. */
+export declare function parseConfig(body: Record<string, unknown> | undefined, previous?: ComputerConfig): ComputerConfig;
+/** One run going on this computer. */
+export interface RunningEntry {
+    run_id: string;
+    agent_id: string;
+    agent_name?: string;
+    agent_avatar_url?: string;
+    title?: string;
+    conversation_key?: string;
+    kind: 'employee' | 'terminal';
+    started_at: string;
+    peak_mem_mb?: number;
+    started_by_user_id?: string;
+}
+export interface Slots {
+    total: number;
+    busy: number;
+    held: number;
+    held_reason: HeldReason | null;
+}
+export declare function slotsFor(capacity: number, busy: number, held: HeldReason | null): Slots;
+export declare function hostStatsBody(stats: HostStats | undefined): Record<string, unknown>;
+/** A login as the status body names it: no email, no directory. */
+export declare function loginBody(login: LoginInfo, conversations: number): Record<string, unknown>;
+export interface StatusInputs {
+    stats: HostStats | undefined;
+    slots: Slots;
+    logins: readonly LoginInfo[];
+    conversationsPerLogin: ReadonlyMap<string, number>;
+    running: readonly RunningEntry[];
+    cliVersion: string;
+    capabilities: readonly string[];
+    recommendedCapacity: number;
+    /** Running as a dedicated service (keeps working when no one is logged in). */
+    dedicated?: boolean;
+}
+/** `POST /v1/computers/{id}/status` body. */
+export declare function buildStatusBody(inputs: StatusInputs): Record<string, unknown>;
+/** A run as `host status --json` and `activity.json` show it. */
+export declare function localRunning(entry: RunningEntry): Record<string, unknown>;
+/** A login as `host status --json` / `host logins --json` show it (local: includes the email). */
+export declare function localLogin(login: LoginInfo): Record<string, unknown>;
+/** `state.json`: what the running service last knew. */
+export interface HostState {
+    v: 1;
+    pid: number;
+    updatedAt: string;
+    online: boolean;
+    paused: boolean;
+    draining: boolean;
+    slots: Slots;
+    capacity: number;
+    recommended_capacity: number;
+    running: RunningEntry[];
+    logins: LoginInfo[];
+    name?: string;
+}
+/** A state file older than this means no service is running. */
+export declare const STATE_STALE_MS: number;

package/dist/host/status.js

@@ -0,0 +1,130 @@
+/**
+ * What the host tells ProhostAI (`POST /v1/computers/{id}/status`), what it
+ * keeps locally for `prohost host status` and the desktop app (`state.json`,
+ * `activity.json`), and the server's answer (the computer's config).
+ *
+ * The status body never carries a login's email or config directory: those
+ * stay in the local files only.
+ */
+export const DEFAULT_CONFIG = Object.freeze({
+    capacity: null,
+    recommended_capacity: null,
+    hold_on_pressure: true,
+    hold_on_battery: true,
+    ai_employees_enabled: true,
+    terminal_sessions_enabled: true,
+    share_logins: { claude_code: false, codex: false },
+    paused: false,
+    placements: [],
+});
+function bool(value, fallback) {
+    return typeof value === 'boolean' ? value : fallback;
+}
+function count(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : null;
+}
+/** The status answer's `config`, read defensively over the previous one. */
+export function parseConfig(body, previous = DEFAULT_CONFIG) {
+    const raw = body?.config;
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return previous;
+    const c = raw;
+    const share = c.share_logins && typeof c.share_logins === 'object' ? c.share_logins : {};
+    const placements = Array.isArray(c.placements)
+        ? c.placements.flatMap((entry) => {
+            const p = entry;
+            if (!p || typeof p.agent_id !== 'string' || !p.agent_id)
+                return [];
+            const runtime = p.runtime === 'codex' ? 'codex' : 'claude_code';
+            const max = count(p.max_concurrent);
+            return [{ agent_id: p.agent_id, runtime, max_concurrent: max, keep_one_ready: p.keep_one_ready === true }];
+        })
+        : previous.placements;
+    return {
+        ...(typeof c.name === 'string' ? { name: c.name } : previous.name !== undefined ? { name: previous.name } : {}),
+        capacity: c.capacity === null ? null : (count(c.capacity) ?? previous.capacity),
+        recommended_capacity: c.recommended_capacity === null ? null : (count(c.recommended_capacity) ?? previous.recommended_capacity),
+        hold_on_pressure: bool(c.hold_on_pressure, previous.hold_on_pressure),
+        hold_on_battery: bool(c.hold_on_battery, previous.hold_on_battery),
+        ai_employees_enabled: bool(c.ai_employees_enabled, previous.ai_employees_enabled),
+        terminal_sessions_enabled: bool(c.terminal_sessions_enabled, previous.terminal_sessions_enabled),
+        share_logins: {
+            claude_code: bool(share.claude_code, previous.share_logins.claude_code),
+            codex: bool(share.codex, previous.share_logins.codex),
+        },
+        paused: bool(c.paused, previous.paused),
+        placements,
+    };
+}
+export function slotsFor(capacity, busy, held) {
+    return { total: capacity, busy, held: held ? Math.max(0, capacity - busy) : 0, held_reason: held };
+}
+export function hostStatsBody(stats) {
+    return {
+        cpu_pct: stats?.cpuPct ?? null,
+        mem_used_gb: stats?.memUsedGb ?? null,
+        mem_total_gb: stats?.memTotalGb ?? null,
+        memory_pressure: stats?.memoryPressure ?? null,
+        on_battery: stats?.onBattery ?? null,
+        battery_pct: stats?.batteryPct ?? null,
+    };
+}
+/** A login as the status body names it: no email, no directory. */
+export function loginBody(login, conversations) {
+    return {
+        account_key: login.account_key,
+        label: login.label,
+        runtime: login.runtime,
+        subscription_type: login.subscription_type,
+        plan_label: login.plan_label,
+        auth_state: login.auth_state,
+        quota_windows: login.quota_windows.map((w) => ({ ...w })),
+        conversations,
+    };
+}
+/** `POST /v1/computers/{id}/status` body. */
+export function buildStatusBody(inputs) {
+    return {
+        host_stats: hostStatsBody(inputs.stats),
+        slots: { ...inputs.slots },
+        logins: inputs.logins.map((login) => loginBody(login, inputs.conversationsPerLogin.get(login.account_key) ?? 0)),
+        running: inputs.running.map((entry) => ({
+            run_id: entry.run_id,
+            agent_id: entry.agent_id,
+            conversation_key: entry.conversation_key ?? null,
+            kind: entry.kind,
+            started_at: entry.started_at,
+            peak_mem_mb: entry.peak_mem_mb ?? null,
+            ...(entry.started_by_user_id ? { started_by_user_id: entry.started_by_user_id } : {}),
+        })),
+        cli_version: inputs.cliVersion,
+        capabilities: [...inputs.capabilities],
+        recommended_capacity: inputs.recommendedCapacity,
+        ...(inputs.dedicated !== undefined ? { dedicated: inputs.dedicated } : {}),
+    };
+}
+/** A run as `host status --json` and `activity.json` show it. */
+export function localRunning(entry) {
+    return {
+        run_id: entry.run_id,
+        agent: { id: entry.agent_id, name: entry.agent_name ?? null, avatar_url: entry.agent_avatar_url ?? null },
+        title: entry.title ?? null,
+        started_at: entry.started_at,
+        kind: entry.kind,
+    };
+}
+/** A login as `host status --json` / `host logins --json` show it (local: includes the email). */
+export function localLogin(login) {
+    return {
+        account_key: login.account_key,
+        label: login.label,
+        runtime: login.runtime,
+        subscription_type: login.subscription_type,
+        plan_label: login.plan_label,
+        email_local: login.email_local ?? null,
+        auth_state: login.auth_state,
+        windows: login.quota_windows,
+    };
+}
+/** A state file older than this means no service is running. */
+export const STATE_STALE_MS = 2 * 60_000;

package/dist/index.d.ts

@@ -9,6 +9,8 @@
  *     npx @prohost/cli agent run --exec 'claude -p'
  *     npx @prohost/cli agent install-daemon --exec 'claude -p'
  *     npx @prohost/cli usage connect --key <api-key>
+ *     npx @prohost/cli host pair
+ *     npx @prohost/cli host install
  *
  * Parses arguments with a zero-dep, zero-magic flag parser so the published
  * binary stays small and starts fast.
@@ -20,6 +22,8 @@ interface ParsedArgs {
     /** Any further positionals, e.g. ``add work`` in ``prohost agent account add work``. */
     args: string[];
     flags: Record<string, string | boolean>;
+    /** Every value a repeated flag was given, in order (`--from a --from b`); `flags` keeps the last. */
+    repeated: Record<string, string[]>;
 }
 export declare function parseArgs(argv: readonly string[]): ParsedArgs;
 /**

package/dist/index.js

@@ -9,6 +9,8 @@
  *     npx @prohost/cli agent run --exec 'claude -p'
  *     npx @prohost/cli agent install-daemon --exec 'claude -p'
  *     npx @prohost/cli usage connect --key <api-key>
+ *     npx @prohost/cli host pair
+ *     npx @prohost/cli host install
  *
  * Parses arguments with a zero-dep, zero-magic flag parser so the published
  * binary stays small and starts fast.
@@ -19,6 +21,7 @@ import { fileURLToPath } from 'node:url';
 import { endpointProblem } from './agent/base-url.js';
 import { runAgent } from './agent/command.js';
 import { runHook } from './codehost/hooks.js';
+import { runHost } from './host/command.js';
 import { DEFAULT_WS_URL, runListen } from './listen.js';
 import { runUsage } from './usage/command.js';
 import { CLI_VERSION } from './version.js';
@@ -27,6 +30,15 @@ function printHelp() {
         'prohost — ProhostAI CLI',
         '',
         'Usage:',
+        '  prohost host pair [--name <name>] [--token <redeem-token>|-] [--expect-account <workspace-id>]',
+        '                    Add this computer to a workspace (prints a code to enter in ProhostAI)',
+        '  prohost host unpair                  Remove this computer from its workspace (revokes its key)',
+        '  prohost host run                     One service for every AI employee placed on this computer',
+        '  prohost host install [--label <id>] [--dedicated --service-user <name> [--service-home <dir>]',
+        '                       [--claude-token-file <path>]] | uninstall [--label <id>]',
+        '  prohost host status [--json] [--label <id>] | pause | resume',
+        '  prohost host logins [--json] | logins add --runtime claude_code|codex [--label <l>]',
+        '  prohost host migrate [--from <home>]… [--home <dir,…>] [--keep-services] [--dry-run] [--json]',
         '  prohost listen --forward-to <local-url> [--api-key <key>] [--url <ws-url>] [--machine <name>] [--subscription-id <id>]',
         '  prohost agent pair --code <pairing-code> [--expect-account <workspace-id>] [--account <label>]',
         '                     [--webhook-url <https-url>] [--base-url <url>]',
@@ -47,6 +59,33 @@ function printHelp() {
         '  prohost usage discover [--dry-run] | start [--once] [--machine <name>] | status',
         '  prohost usage install-daemon [--machine <name>] | uninstall-daemon',
         '',
+        'host:',
+        '  A computer is added to a workspace once (`host pair`) and serves every AI employee placed on it,',
+        '  running Claude Code or Codex on the AI logins signed in here, plus the terminal sessions opened on it.',
+        '  Employees skip permission prompts (Claude --dangerously-skip-permissions, Codex --yolo); message',
+        '  approval rules still apply. Capacity is recommended from memory and cores and set in ProhostAI.',
+        '  --token          `host pair`: a one-time token from the signed-in desktop app instead of a code',
+        '                   (`-` reads it from stdin; also $PROHOST_REDEEM_TOKEN).',
+        '  --dedicated      `host install`: keep working when no one is logged in (a system service running as',
+        '                   --service-user, created if missing on macOS / Linux; run it as root / an administrator).',
+        '                   It takes over this home\'s computer.json, logs outside the service user\'s home, and',
+        '                   publishes its status for `host status` run by anyone on the computer.',
+        '  --claude-token-file  `host install --dedicated`: a file holding a `claude setup-token` token, installed',
+        '                   for the service user as CLAUDE_CODE_OAUTH_TOKEN. Read once, never printed.',
+        '  --from-home      `host install --dedicated`: the home whose computer.json the service takes over',
+        "                   (default: $PROHOST_HOME, or $SUDO_USER's ~/.prohost under sudo).",
+        '  --label          `host install` / `uninstall`: the service\'s label (launchd label, systemd unit,',
+        '                   Windows task), e.g. ai.prohost.desktop.host. Default: ai.prohost.host for ~/.prohost,',
+        '                   or one derived from $PROHOST_HOME. Re-running install changes nothing that is right.',
+        '  Under the ProhostAI desktop app, host install keeps ELECTRON_RUN_AS_NODE=1 in the service it writes',
+        '                   (and the PATH it was launched with), so the service runs the CLI, never the app.',
+        '  `host unpair` removes this computer from its workspace and deletes its key here.',
+        '  `host logins add` signs in another Claude Code / Codex login in this terminal.',
+        '  `host pause` takes no new work until `host resume`; work already going finishes.',
+        '  `host migrate` adopts existing agent homes and the desktop app\'s terminal-hosting home, keeping',
+        '  their credentials and becoming a computer through their agent keys (no new pairing). --from <home>',
+        '  (repeatable) adopts only those homes and never changes them (see the README).',
+        '',
         'listen flags:',
         '  --forward-to     Local URL to POST each webhook payload to (required)',
         '  --api-key        ProhostAI API key. Defaults to $PROHOST_API_KEY.',
@@ -152,6 +191,7 @@ function printHelp() {
 }
 export function parseArgs(argv) {
     const flags = {};
+    const repeated = {};
     let command;
     let subcommand;
     const args = [];
@@ -187,10 +227,11 @@ export function parseArgs(argv) {
         }
         else {
             flags[key] = next;
+            (repeated[key] ??= []).push(next);
             i += 2;
         }
     }
-    return { command, subcommand, args, flags };
+    return { command, subcommand, args, flags, repeated };
 }
 /**
  * The `hook` command's arguments as the hook reads them: its positionals, and
@@ -201,7 +242,7 @@ export function hookArgs({ subcommand, args, flags }) {
     return [subcommand ?? '', ...args, ...(typeof wait === 'string' ? ['--wait', wait] : [])];
 }
 async function main(argv) {
-    const { command, subcommand, args, flags } = parseArgs(argv);
+    const { command, subcommand, args, flags, repeated } = parseArgs(argv);
     // Checked before the help/no-command branch: `prohost --version` carries no
     // command, which would otherwise print help and exit 1.
     if (flags.version) {
@@ -223,12 +264,15 @@ async function main(argv) {
     if (command === 'agent') {
         return runAgent(subcommand, flags, printHelp, args);
     }
+    if (command === 'host') {
+        return runHost(subcommand, flags, printHelp, { args, repeated });
+    }
     if (command === 'usage') {
         return runUsage(subcommand, flags, printHelp);
     }
     // Run by the Code-thread hook shim (codehost/hooks.ts), not by people; not in --help.
     if (command === 'hook') {
-        return runHook(hookArgs({ command, subcommand, args, flags }));
+        return runHook(hookArgs({ command, subcommand, args, flags, repeated }));
     }
     if (command !== 'listen') {
         process.stderr.write(`Unknown command: ${command}\n\n`);