@phnx-labs/agents-cli 1.20.93 → 1.21.0

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;

package/dist/lib/hq/floor.js

@@ -1,243 +0,0 @@
-import { mailboxIdForActiveSession } from '../mailbox-target.js';
-function slug(s) {
-    return s.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '') || 'unknown';
-}
-function roomIdForTeam(team) {
-    return `team:${slug(team)}`;
-}
-function roomIdForMachine(machine) {
-    return `machine:${slug(machine)}`;
-}
-function agentDisplayName(session) {
-    return session.name || session.label || session.agentId || session.sessionId?.slice(0, 8) || session.kind;
-}
-function sessionMachine(session) {
-    return session.machine || session.provenance?.host || session.host || 'local';
-}
-function teamForSession(session, teammatesById) {
-    if (session.teamName)
-        return session.teamName;
-    if (session.agentId && teammatesById.has(session.agentId))
-        return teammatesById.get(session.agentId).team;
-    return undefined;
-}
-function teammateName(session, teammatesById) {
-    if (session.agentId && teammatesById.has(session.agentId)) {
-        return teammatesById.get(session.agentId).name || session.agentId.slice(0, 8);
-    }
-    return session.agentId;
-}
-function moodForSession(session, hasOpenBlock) {
-    if (session.status === 'abandoned')
-        return 'blocked';
-    // A crashed session is NOT `done` — it stopped without finishing, and its last
-    // parsed turn often still says `working`, which would otherwise reach the Floor
-    // as a happily-running agent. Both lost-host states need a human.
-    if (session.status === 'crashed')
-        return 'blocked';
-    // An orphaned session that is genuinely mid-question needs an answer; one that
-    // is merely idle-and-unwatched needs someone to reattach or clean it up. Same
-    // distinction `isAwaitingUser` draws — giving both the high-intensity "needs
-    // input" alert would train the operator to ignore it.
-    if (session.status === 'orphaned') {
-        return session.activity === 'waiting_input' ? 'waiting' : 'blocked';
-    }
-    if (session.status === 'closed')
-        return 'done';
-    if (session.status === 'input_required' || session.activity === 'waiting_input' || hasOpenBlock)
-        return 'waiting';
-    if (session.rateLimited)
-        return 'blocked';
-    if (session.pr)
-        return 'celebrating';
-    if (session.status === 'running' || session.activity === 'working')
-        return 'working';
-    return 'idle';
-}
-function action(id, label, command, target, extra = {}) {
-    return { id, label, command, target, ...extra };
-}
-function agentActions(agentId, session, mailboxId, team, teammate) {
-    const actions = [];
-    if (mailboxId) {
-        actions.push(action(`agent:${agentId}:message`, 'Message', ['message', mailboxId, '{message}', '--surface', 'hq'], { kind: 'agent', id: agentId }, { input: [{ name: 'message', label: 'Message', placeholder: 'What should this agent do next?', required: true }] }));
-        actions.push(action(`agent:${agentId}:stop`, 'Stop', ['feed', '--kill', mailboxId], { kind: 'agent', id: agentId }, { destructive: true }));
-    }
-    if (team && teammate) {
-        actions.push(action(`agent:${agentId}:team-stop`, 'Stop teammate', ['teams', 'stop', team, teammate], { kind: 'agent', id: agentId }, { destructive: true }));
-    }
-    if (session.sessionId) {
-        actions.push(action(`agent:${agentId}:transcript`, 'Transcript', ['sessions', session.sessionId, '--markdown'], { kind: 'agent', id: agentId }));
-    }
-    return actions;
-}
-function spawnActionForRoom(roomId, team) {
-    if (team) {
-        return action(`room:${roomId}:spawn-teammate`, 'Spawn teammate', ['teams', 'add', team, '{agent}', '{task}', '--name', '{name}', '--mode', 'edit'], { kind: 'room', id: roomId }, {
-            input: [
-                { name: 'agent', label: 'Agent', placeholder: 'claude', required: true },
-                { name: 'name', label: 'Name', placeholder: 'frontend', required: true },
-                { name: 'task', label: 'Task', placeholder: 'Implement the next scoped task', required: true },
-            ],
-        });
-    }
-    return action(`room:${roomId}:spawn-run`, 'Run agent', ['run', '{agent}', '{task}', '--name', '{name}'], { kind: 'room', id: roomId }, {
-        input: [
-            { name: 'agent', label: 'Agent', placeholder: 'claude', required: true },
-            { name: 'name', label: 'Name', placeholder: 'investigate', required: true },
-            { name: 'task', label: 'Task', placeholder: 'Investigate this room', required: true },
-        ],
-    });
-}
-export function buildHqFloor(input) {
-    const generatedAt = (input.generatedAt ?? new Date()).toISOString();
-    const teammatesById = new Map();
-    for (const [team, teammates] of input.teammatesByTeam) {
-        for (const teammate of teammates)
-            teammatesById.set(teammate.agent_id, { ...teammate, team });
-    }
-    const openBlocksByMailbox = new Map();
-    for (const block of input.blocks) {
-        const blocks = openBlocksByMailbox.get(block.mailboxId) || [];
-        blocks.push(block);
-        openBlocksByMailbox.set(block.mailboxId, blocks);
-    }
-    const rooms = new Map();
-    const ensureRoom = (room) => {
-        const existing = rooms.get(room.id);
-        if (existing)
-            return existing;
-        const created = {
-            ...room,
-            counts: { agents: 0, needsInput: 0, running: 0, failed: 0 },
-            actions: [spawnActionForRoom(room.id, room.team)],
-        };
-        rooms.set(room.id, created);
-        return created;
-    };
-    for (const team of input.teams) {
-        ensureRoom({ id: roomIdForTeam(team.task_name), kind: 'team', name: team.task_name, team: team.task_name });
-    }
-    const agents = [];
-    for (const session of input.sessions) {
-        const team = teamForSession(session, teammatesById);
-        const machine = sessionMachine(session);
-        const room = team
-            ? ensureRoom({ id: roomIdForTeam(team), kind: 'team', name: team, team })
-            : ensureRoom({ id: roomIdForMachine(machine), kind: 'machine', name: machine, machine });
-        const mailboxId = mailboxIdForActiveSession(session);
-        const blocks = mailboxId ? openBlocksByMailbox.get(mailboxId) || [] : [];
-        const id = session.agentId || session.sessionId || `${session.kind}:${agents.length + 1}`;
-        const mood = moodForSession(session, blocks.length > 0);
-        const teammate = teammateName(session, teammatesById);
-        room.counts.agents++;
-        if (mood === 'waiting')
-            room.counts.needsInput++;
-        if (session.status === 'running')
-            room.counts.running++;
-        if (mood === 'blocked')
-            room.counts.failed++;
-        agents.push({
-            id,
-            label: agentDisplayName(session),
-            agent: session.kind,
-            roomId: room.id,
-            mood,
-            status: session.status,
-            activity: session.activity,
-            preview: session.preview || session.question?.text,
-            machine,
-            team,
-            teammate,
-            sessionId: session.sessionId,
-            mailboxId,
-            pid: session.pid,
-            prUrl: session.pr?.url,
-            ticketId: session.ticket?.id,
-            actions: agentActions(id, session, mailboxId, team, teammate),
-        });
-    }
-    const ambientEvents = [];
-    for (const agent of agents) {
-        if (agent.mood === 'waiting') {
-            ambientEvents.push({
-                id: `needs-input:${agent.id}`,
-                kind: 'needs_input',
-                roomId: agent.roomId,
-                agentId: agent.id,
-                label: `${agent.label} needs input`,
-                intensity: 'high',
-            });
-        }
-        else if (agent.mood === 'blocked') {
-            ambientEvents.push({
-                id: `blocked:${agent.id}`,
-                kind: 'error',
-                roomId: agent.roomId,
-                agentId: agent.id,
-                label: `${agent.label} is blocked`,
-                intensity: 'high',
-            });
-        }
-        else if (agent.mood === 'celebrating' && agent.prUrl) {
-            ambientEvents.push({
-                id: `pr:${agent.id}`,
-                kind: 'pr',
-                roomId: agent.roomId,
-                agentId: agent.id,
-                label: `${agent.label} opened a PR`,
-                intensity: 'medium',
-            });
-        }
-    }
-    for (const room of rooms.values()) {
-        const roomAgents = agents.filter((agent) => agent.roomId === room.id);
-        if (room.kind === 'team' && room.counts.running > 0) {
-            ambientEvents.push({
-                id: `team-active:${room.id}`,
-                kind: 'team_active',
-                roomId: room.id,
-                label: `${room.name} has ${room.counts.running} active teammate${room.counts.running === 1 ? '' : 's'}`,
-                intensity: 'low',
-            });
-        }
-        if (roomAgents.length > 0 && roomAgents.every((agent) => agent.mood === 'idle')) {
-            ambientEvents.push({
-                id: `idle:${room.id}`,
-                kind: 'idle_scene',
-                roomId: room.id,
-                label: `${room.name} is calm`,
-                intensity: 'low',
-            });
-        }
-    }
-    const floorActions = [
-        action('floor:create-team', 'Create team room', ['teams', 'create', '{team}', '--description', '{description}'], { kind: 'floor', id: 'floor' }, {
-            input: [
-                { name: 'team', label: 'Team', placeholder: 'release-squad', required: true },
-                { name: 'description', label: 'Description', placeholder: 'What this room owns' },
-            ],
-        }),
-    ];
-    const roomList = [...rooms.values()].sort((a, b) => {
-        if (a.kind !== b.kind)
-            return a.kind === 'team' ? -1 : 1;
-        return a.name.localeCompare(b.name);
-    });
-    return {
-        version: 1,
-        generatedAt,
-        counters: {
-            rooms: roomList.length,
-            agents: agents.length,
-            teams: input.teams.length,
-            needsInput: agents.filter((agent) => agent.mood === 'waiting').length,
-            failed: agents.filter((agent) => agent.mood === 'blocked').length,
-            prs: agents.filter((agent) => agent.prUrl).length,
-        },
-        rooms: roomList,
-        agents,
-        ambientEvents,
-        actions: floorActions,
-    };
-}

package/dist/lib/session/sync/crdt.d.ts

@@ -1,44 +0,0 @@
-/**
- * CRDT merge for agent transcripts.
- *
- * A transcript (Claude JSONL, Codex JSONL, …) is an append-only log of
- * immutable events: each line is written once and never rewritten, and Claude
- * already tolerates branches within one file (parentUuid fan-out). That makes a
- * transcript a grow-only set (G-Set) of events, and merging two copies of the
- * same session is a set union — associative, commutative, idempotent. Two
- * machines that each appended to the same session therefore converge to the
- * exact same merged file regardless of sync order or timing, with zero conflict
- * resolution and zero data loss.
- *
- * Events are identified by the SHA-256 of their raw line bytes. We deliberately
- * do NOT key on a per-event `uuid`: Codex lines carry no id, and because an
- * event is written exactly once and then copied verbatim across machines, the
- * raw bytes are a stable, agent-agnostic identity. Multiplicity is preserved
- * (some transcripts contain legitimately identical lines, e.g. paired
- * `queue-operation` entries) by taking the per-hash max count across sources.
- */
-export interface ParsedEvent {
-    /** Original line bytes, exactly as stored (no trailing newline). */
-    raw: string;
-    /** SHA-256 of `raw` — the event's identity. */
-    hash: string;
-    /** Top-level ISO `timestamp`, or '' when absent/unparseable. */
-    ts: string;
-}
-/** Parse a transcript's raw text into events, skipping blank lines. */
-export declare function parseTranscript(content: string): ParsedEvent[];
-/**
- * Merge copies of the same session into one transcript via G-Set union.
- *
- * Returns a source VERBATIM (no reordering, byte-identical) for the common
- * cases — one source, all sources identical, or one source a superset of the
- * rest — so the steady state never rewrites unchanged files. Only a true fork
- * (each side holds events the other lacks) produces a reordered union, sorted
- * by (timestamp, hash) so every machine derives identical bytes.
- */
-export declare function mergeTranscripts(contents: string[]): string;
-/** Count distinct + total events across copies (for logging / manifest stats). */
-export declare function transcriptStats(content: string): {
-    events: number;
-    lastTs: string;
-};