@phnx-labs/agents-cli 1.20.93 → 1.21.1

package/dist/commands/sync-provision.js

@@ -1,107 +0,0 @@
-/**
- * Interactive provisioning flow for cross-machine session sync. Collects R2
- * credentials, writes the `r2.backups` bundle (via the pure lib helper), probes
- * connectivity, and opts the machine into the `session-sync` beta. Shared by
- * `agents setup` (offered, opt-in) and `agents sessions sync --setup` (explicit).
- *
- * The prompt/UI lives here in the command layer; the credential-writing and
- * connectivity logic is the pure, unit-tested `lib/session/sync/provision.ts`.
- */
-import chalk from 'chalk';
-import ora from 'ora';
-import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
-import { isSyncConfigured } from '../lib/session/sync/config.js';
-import { writeSyncBundle, probeR2Connectivity, readStoredEncKey } from '../lib/session/sync/provision.js';
-import { setBetaEnabled } from '../lib/beta.js';
-const SYNC_BETA = 'session-sync';
-const nonEmpty = (v) => (v.trim().length > 0 ? true : 'required');
-/**
- * Run the guided session-sync setup. Never throws for expected outcomes
- * (non-interactive shell, user declines, cancels, or a failed probe) — returns
- * quietly so a first-run `agents setup` is never blocked by the optional step.
- */
-export async function promptAndProvisionSessionSync(opts = {}) {
-    if (!isInteractiveTerminal()) {
-        if (opts.explicit)
-            console.error(chalk.red('Session-sync setup needs an interactive terminal.'));
-        return;
-    }
-    const alreadyConfigured = isSyncConfigured();
-    const { confirm, input, password } = await import('@inquirer/prompts');
-    try {
-        if (!opts.explicit) {
-            if (alreadyConfigured)
-                return; // first-run setup: nothing to do
-            const want = await confirm({
-                message: 'Set up cross-machine session sync (encrypted transcripts via Cloudflare R2)?',
-                default: false,
-            });
-            if (!want)
-                return;
-        }
-        else if (alreadyConfigured) {
-            const reconfigure = await confirm({
-                message: 'Session sync is already configured. Re-enter R2 credentials?',
-                default: false,
-            });
-            if (!reconfigure) {
-                const key = readStoredEncKey();
-                if (key) {
-                    console.log(chalk.dim('\nShared encryption key (paste on every other machine you sync):'));
-                    console.log('  ' + chalk.cyan(key));
-                }
-                return;
-            }
-        }
-        console.log(chalk.dim('\nR2 credentials — Cloudflare dashboard > R2 > Manage API Tokens (needs read+write):'));
-        const accountId = (await input({ message: 'R2 account ID:', validate: nonEmpty })).trim();
-        const bucketName = (await input({ message: 'R2 bucket name:', validate: nonEmpty })).trim();
-        const accessKeyId = (await password({ message: 'R2 access key ID:', mask: true })).trim();
-        const secretAccessKey = (await password({ message: 'R2 secret access key:', mask: true })).trim();
-        const endpoint = (await input({
-            message: 'S3 endpoint override (blank = Cloudflare R2):',
-            default: '',
-        })).trim();
-        // Encryption key: the first machine mints one; every other machine pastes it
-        // so the whole fabric shares a single key (and can decrypt each other).
-        const firstMachine = await confirm({ message: 'Is this the FIRST machine in your sync fabric?', default: true });
-        let encKey;
-        if (!firstMachine) {
-            encKey = (await password({
-                message: 'Paste the shared R2_SYNC_ENC_KEY from your first machine:',
-                mask: true,
-                validate: nonEmpty,
-            })).trim();
-        }
-        const { encKeyAction } = writeSyncBundle({
-            accountId, bucketName, accessKeyId, secretAccessKey,
-            endpoint: endpoint || undefined,
-            encKey: encKey || undefined,
-        });
-        const spinner = ora('Validating R2 read+write...').start();
-        const probe = await probeR2Connectivity();
-        if (!probe.ok) {
-            spinner.fail(`R2 probe failed: ${probe.error}`);
-            console.log(chalk.yellow('Credentials were saved to the r2.backups bundle but not verified. Fix them and re-run ' +
-                '`agents sessions sync --setup`, or rotate one key with `agents secrets rotate r2.backups <KEY>`.'));
-            return; // do not auto-enable sync against credentials that don't work
-        }
-        spinner.succeed('R2 read+write verified.');
-        setBetaEnabled([SYNC_BETA], true);
-        console.log(chalk.green('\nSession sync configured and enabled') + chalk.dim(' (the daemon syncs every ~90s).'));
-        if (encKeyAction === 'generated') {
-            const key = readStoredEncKey();
-            console.log(chalk.bold('\nShared encryption key — paste this on every OTHER machine you sync:'));
-            console.log('  ' + chalk.cyan(key ?? '(unavailable)'));
-            console.log(chalk.dim('Anyone with this key can decrypt your transcripts. Keep it secret.'));
-        }
-        console.log(chalk.dim('\nSync now with: agents sessions sync'));
-    }
-    catch (err) {
-        if (isPromptCancelled(err)) {
-            console.log(chalk.yellow('\nSession-sync setup cancelled.'));
-            return;
-        }
-        throw err;
-    }
-}

package/dist/lib/drive-sync.d.ts

@@ -1,45 +0,0 @@
-/**
- * Remote drive sync for agent sessions and config.
- *
- * Provides rsync-based push/pull between the local ~/.agents/drive/
- * directory and a remote host, plus attach/detach to swap the active
- * agent's config directory symlink to the drive directory (for working
- * with a remote machine's session data locally).
- */
-/** Persisted drive configuration stored at ~/.agents/drive/config.json. */
-export interface DriveConfig {
-    remote: string | null;
-    attached: boolean;
-    previousTargets: {
-        configDir: string;
-        homeFiles: Record<string, string>;
-    } | null;
-    lastPull: string | null;
-    lastPush: string | null;
-}
-/** Read drive config from disk, returning defaults if missing. */
-export declare function readDriveConfig(): DriveConfig;
-/** Write drive config to disk. */
-export declare function writeDriveConfig(config: DriveConfig): void;
-/** Set the remote target (user@host) for rsync operations. */
-export declare function setRemote(target: string): void;
-/** Pull drive data from the remote host via rsync. */
-export declare function pull(): Promise<void>;
-/** Push local drive data to the remote host via rsync. */
-export declare function push(): Promise<void>;
-/** Attach drive by swapping the agent's config directory symlink to the drive directory. */
-export declare function attach(): void;
-/** Detach drive by restoring the agent's config directory to its previous symlink target. */
-export declare function detach(): void;
-/** Current drive state for display purposes. */
-export interface DriveStatus {
-    remote: string | null;
-    attached: boolean;
-    lastPull: string | null;
-    lastPush: string | null;
-    driveDir: string;
-    configDirTarget: string | null;
-    homeFileTargets: Record<string, string | null>;
-}
-/** Gather current drive status by inspecting config, symlinks, and timestamps. */
-export declare function getDriveStatus(): DriveStatus;

package/dist/lib/drive-sync.js

@@ -1,238 +0,0 @@
-/**
- * Remote drive sync for agent sessions and config.
- *
- * Provides rsync-based push/pull between the local ~/.agents/drive/
- * directory and a remote host, plus attach/detach to swap the active
- * agent's config directory symlink to the drive directory (for working
- * with a remote machine's session data locally).
- */
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { execFile } from 'child_process';
-import { promisify } from 'util';
-import { getDriveDir } from './state.js';
-import { AGENTS } from './agents.js';
-import { sshExec } from './ssh-exec.js';
-const execFileAsync = promisify(execFile);
-// `remote` flows from disk into rsync/ssh argv. Use a strict regex so a
-// tampered ~/.agents/drive/config.json can't sneak shell metacharacters or
-// argv flags (leading -) past the boundary.
-const REMOTE_RE = /^[a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+$/;
-function assertValidRemote(remote) {
-    if (!REMOTE_RE.test(remote)) {
-        throw new Error(`Invalid drive remote: ${JSON.stringify(remote)}. Expected: user@host`);
-    }
-}
-const AGENT = 'claude';
-function configPath() {
-    return path.join(getDriveDir(), 'config.json');
-}
-/** Read drive config from disk, returning defaults if missing. */
-export function readDriveConfig() {
-    const p = configPath();
-    if (fs.existsSync(p)) {
-        try {
-            const parsed = JSON.parse(fs.readFileSync(p, 'utf-8'));
-            // Re-validate `remote` on every read. setRemote validates on write, but
-            // the file can be tampered with out-of-band (a malicious skill, a synced
-            // config from a hostile repo, etc.) and pull/push shell out with the value.
-            if (parsed.remote != null) {
-                assertValidRemote(parsed.remote);
-            }
-            return parsed;
-        }
-        catch (err) {
-            // If the config is malformed or has a tainted remote, fail closed rather
-            // than silently fall back to defaults — a tainted remote that fell back
-            // to null would mask the attack.
-            if (err instanceof SyntaxError) {
-                // Bad JSON: fall through to defaults.
-            }
-            else {
-                throw err;
-            }
-        }
-    }
-    return { remote: null, attached: false, previousTargets: null, lastPull: null, lastPush: null };
-}
-/** Write drive config to disk. */
-export function writeDriveConfig(config) {
-    const dir = getDriveDir();
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(configPath(), JSON.stringify(config, null, 2));
-}
-/** Set the remote target (user@host) for rsync operations. */
-export function setRemote(target) {
-    assertValidRemote(target);
-    const config = readDriveConfig();
-    config.remote = target;
-    writeDriveConfig(config);
-}
-/** Pull drive data from the remote host via rsync. */
-export async function pull() {
-    const config = readDriveConfig();
-    if (!config.remote)
-        throw new Error('No remote configured. Run: agents drive remote <user@host>');
-    assertValidRemote(config.remote);
-    const localDir = getDriveDir() + '/';
-    const remoteSpec = `${config.remote}:~/.agents/drive/`;
-    // Argv form: no shell, no interpolation — even a tainted `config.remote` that
-    // somehow got past the regex cannot escape into command syntax.
-    await execFileAsync('rsync', ['-az', '--exclude=config.json', remoteSpec, localDir]);
-    config.lastPull = new Date().toISOString();
-    writeDriveConfig(config);
-}
-/** Push local drive data to the remote host via rsync. */
-export async function push() {
-    const config = readDriveConfig();
-    if (!config.remote)
-        throw new Error('No remote configured. Run: agents drive remote <user@host>');
-    assertValidRemote(config.remote);
-    const localDir = getDriveDir() + '/';
-    const remoteSpec = `${config.remote}:~/.agents/drive/`;
-    // Ensure remote directory exists via the shared hardened SSH primitive.
-    const mkdir = sshExec(config.remote, 'mkdir -p ~/.agents/drive', { timeoutMs: 30_000 });
-    if (mkdir.code !== 0) {
-        throw new Error(`Failed to prepare remote drive directory on ${config.remote}${mkdir.stderr.trim() ? `: ${mkdir.stderr.trim()}` : ''}`);
-    }
-    await execFileAsync('rsync', ['-az', '--exclude=config.json', localDir, remoteSpec]);
-    config.lastPush = new Date().toISOString();
-    writeDriveConfig(config);
-}
-/** Attach drive by swapping the agent's config directory symlink to the drive directory. */
-export function attach() {
-    const config = readDriveConfig();
-    if (config.attached)
-        throw new Error('Drive is already attached');
-    const home = os.homedir();
-    const agentConfig = AGENTS[AGENT];
-    const driveDir = getDriveDir();
-    const configDirPath = agentConfig.configDir; // ~/.claude
-    const driveConfigDir = path.join(driveDir, `.${AGENT}`); // ~/.agents/drive/.claude
-    // Read current symlink target
-    let prevConfigDir = null;
-    try {
-        const stat = fs.lstatSync(configDirPath);
-        if (stat.isSymbolicLink()) {
-            prevConfigDir = fs.readlinkSync(configDirPath);
-        }
-    }
-    catch {
-        // Path doesn't exist
-    }
-    if (!prevConfigDir) {
-        throw new Error(`${configDirPath} is not a symlink. Run 'agents use claude' first.`);
-    }
-    // Save previous targets for home files
-    const prevHomeFiles = {};
-    for (const hf of agentConfig.homeFiles || []) {
-        const hfPath = path.join(home, hf);
-        try {
-            const stat = fs.lstatSync(hfPath);
-            if (stat.isSymbolicLink()) {
-                prevHomeFiles[hf] = fs.readlinkSync(hfPath);
-            }
-        }
-        catch {
-            // File doesn't exist
-        }
-    }
-    config.previousTargets = {
-        configDir: prevConfigDir,
-        homeFiles: prevHomeFiles,
-    };
-    // Ensure drive config dir exists
-    if (!fs.existsSync(driveConfigDir)) {
-        fs.mkdirSync(driveConfigDir, { recursive: true });
-    }
-    // Swap config dir symlink
-    fs.unlinkSync(configDirPath);
-    fs.symlinkSync(driveConfigDir, configDirPath);
-    // Swap home files
-    for (const hf of agentConfig.homeFiles || []) {
-        const hfPath = path.join(home, hf);
-        const driveHfPath = path.join(driveDir, hf);
-        if (!fs.existsSync(driveHfPath)) {
-            fs.writeFileSync(driveHfPath, '{}');
-        }
-        try {
-            fs.unlinkSync(hfPath);
-        }
-        catch { /* doesn't exist */ }
-        fs.symlinkSync(driveHfPath, hfPath);
-    }
-    config.attached = true;
-    writeDriveConfig(config);
-}
-/** Detach drive by restoring the agent's config directory to its previous symlink target. */
-export function detach() {
-    const config = readDriveConfig();
-    if (!config.attached)
-        throw new Error('Drive is not attached');
-    if (!config.previousTargets)
-        throw new Error('No previous targets saved');
-    const home = os.homedir();
-    const agentConfig = AGENTS[AGENT];
-    // Restore config dir symlink
-    const configDirPath = agentConfig.configDir;
-    fs.unlinkSync(configDirPath);
-    fs.symlinkSync(config.previousTargets.configDir, configDirPath);
-    // Restore home files
-    for (const hf of agentConfig.homeFiles || []) {
-        const hfPath = path.join(home, hf);
-        const prevTarget = config.previousTargets.homeFiles[hf];
-        if (prevTarget) {
-            try {
-                fs.unlinkSync(hfPath);
-            }
-            catch { /* doesn't exist */ }
-            fs.symlinkSync(prevTarget, hfPath);
-        }
-    }
-    config.attached = false;
-    config.previousTargets = null;
-    writeDriveConfig(config);
-}
-/** Gather current drive status by inspecting config, symlinks, and timestamps. */
-export function getDriveStatus() {
-    const config = readDriveConfig();
-    const home = os.homedir();
-    const agentConfig = AGENTS[AGENT];
-    let configDirTarget = null;
-    try {
-        const stat = fs.lstatSync(agentConfig.configDir);
-        if (stat.isSymbolicLink()) {
-            configDirTarget = fs.readlinkSync(agentConfig.configDir);
-        }
-    }
-    catch {
-        // Not a symlink or doesn't exist
-    }
-    const homeFileTargets = {};
-    for (const hf of agentConfig.homeFiles || []) {
-        try {
-            const stat = fs.lstatSync(path.join(home, hf));
-            if (stat.isSymbolicLink()) {
-                homeFileTargets[hf] = fs.readlinkSync(path.join(home, hf));
-            }
-            else {
-                homeFileTargets[hf] = null;
-            }
-        }
-        catch {
-            homeFileTargets[hf] = null;
-        }
-    }
-    return {
-        remote: config.remote,
-        attached: config.attached,
-        lastPull: config.lastPull,
-        lastPush: config.lastPush,
-        driveDir: getDriveDir(),
-        configDirTarget,
-        homeFileTargets,
-    };
-}

package/dist/lib/hq/floor.d.ts

@@ -1,87 +0,0 @@
-import type { ActiveSession } from '../session/active.js';
-import type { OpenBlock } from '../feed.js';
-import type { AgentStatusDetail, TaskInfo } from '../teams/api.js';
-export type HqRoomKind = 'team' | 'machine' | 'lobby';
-export type HqAgentMood = 'working' | 'waiting' | 'blocked' | 'celebrating' | 'done' | 'idle';
-export type HqAmbientKind = 'needs_input' | 'error' | 'pr' | 'team_active' | 'idle_scene';
-export interface HqAction {
-    id: string;
-    label: string;
-    command: string[];
-    target: {
-        kind: 'agent' | 'room' | 'floor';
-        id: string;
-    };
-    destructive?: boolean;
-    input?: Array<{
-        name: string;
-        label: string;
-        placeholder?: string;
-        required?: boolean;
-    }>;
-}
-export interface HqRoom {
-    id: string;
-    kind: HqRoomKind;
-    name: string;
-    machine?: string;
-    team?: string;
-    counts: {
-        agents: number;
-        needsInput: number;
-        running: number;
-        failed: number;
-    };
-    actions: HqAction[];
-}
-export interface HqAgent {
-    id: string;
-    label: string;
-    agent: string;
-    roomId: string;
-    mood: HqAgentMood;
-    status: string;
-    activity?: string;
-    preview?: string;
-    machine?: string;
-    team?: string;
-    teammate?: string;
-    sessionId?: string;
-    mailboxId?: string;
-    pid?: number;
-    prUrl?: string;
-    ticketId?: string;
-    actions: HqAction[];
-}
-export interface HqAmbientEvent {
-    id: string;
-    kind: HqAmbientKind;
-    roomId: string;
-    agentId?: string;
-    label: string;
-    intensity: 'low' | 'medium' | 'high';
-}
-export interface HqFloorSnapshot {
-    version: 1;
-    generatedAt: string;
-    counters: {
-        rooms: number;
-        agents: number;
-        teams: number;
-        needsInput: number;
-        failed: number;
-        prs: number;
-    };
-    rooms: HqRoom[];
-    agents: HqAgent[];
-    ambientEvents: HqAmbientEvent[];
-    actions: HqAction[];
-}
-export interface BuildHqFloorInput {
-    generatedAt?: Date;
-    sessions: ActiveSession[];
-    teams: TaskInfo[];
-    teammatesByTeam: Map<string, AgentStatusDetail[]>;
-    blocks: OpenBlock[];
-}
-export declare function buildHqFloor(input: BuildHqFloorInput): HqFloorSnapshot;