@phnx-labs/agents-cli 1.22.41 → 1.22.43

package/dist/commands/routines.js

@@ -13,6 +13,7 @@ import * as yaml from 'yaml';
 import { isDaemonRunning, signalDaemonReload, startDaemon, stopDaemon, readDaemonLog, getDaemonStatus, getDaemonLogPath, } from '../lib/daemon/daemon.js';
 import { assertSchedulerEnabled, assertDaemonEnabled, isDaemonEnabled } from '../lib/device-config.js';
 import { parseAgentVersionSpec, isAgentHardDeprecated, hardDeprecationError, ROUTINE_AGENT_IDS } from '../lib/agents.js';
+import { isCustomHarnessName } from '../lib/profiles.js';
 import { RUN_STRATEGIES, normalizeRunStrategy } from '../lib/accounting/rotate.js';
 import { formatRepoLink, REPO_DISPLAY_MAX } from '../lib/routines-format.js';
 import { listJobs as listAllJobs, deleteJob, readJob, validateJob, writeJob, setJobEnabled, listRuns, routineStats, getLatestRun, getRunDir, getJobPath, isCanonicalRoutineSource, parseAtTime, hasCompletedOneShotRun, isOneShotLikeSchedule, isOneShotRoutine, jobRunsOnThisDevice, checkJobDeviceEligibility, normalizeTriggerEvent, parseHostStrategy, resolveHostStrategy, HOST_STRATEGIES, computeProjectGroupKind, projectGroupKey, projectGroupTitle, projectGroupOrder, normalizeProjects, buildRoutineListJson, fireConditionLabel, nextRunForDisplay, nextRunLabel, localLatestRun, listJobsForDisplay, } from '../lib/scheduling/routines.js';
@@ -24,7 +25,7 @@ import { fireWebhookJobs, matchJobsToWebhook } from '../lib/triggers/webhook.js'
 import { getRoutinesDir } from '../lib/state.js';
 import { IS_WINDOWS } from '../lib/platform/index.js';
 import { safeJoin } from '../lib/paths.js';
-import { executeJob, monitorRunningJobs } from '../lib/runner.js';
+import { executeJob, monitorRunningJobs } from '../lib/daemon/runner.js';
 import { JobScheduler } from '../lib/scheduler.js';
 import { detectOverdueJobs } from '../lib/overdue.js';
 import { runCatchup } from '../lib/catchup.js';
@@ -897,7 +898,7 @@ export function registerRoutinesCommands(program) {
         .command('add [nameOrPath]')
         .description('Create a new routine from a YAML file or inline flags. Starts the scheduler automatically if it is not already running.')
         .option('-s, --schedule <cron>', 'Cron schedule in standard format (5 fields: minute hour day month weekday)')
-        .option('-a, --agent <agent[@version]>', `Which agent runs this routine: ${ROUTINE_AGENT_IDS.join(', ')}. An @version pins that exact installed version (same syntax as agents run), persisted as separate agent + version fields.`)
+        .option('-a, --agent <agent[@version]>', `Which agent runs this routine: ${ROUTINE_AGENT_IDS.join(', ')}, or a custom harness name (agents harness list). An @version pins that exact installed version (same syntax as agents run), persisted as separate agent + version fields; a custom harness pins its own host version.`)
         .option('--strategy <strategy>', `Version/account selection strategy for this routine: ${RUN_STRATEGIES.join(' | ')}. Overrides run.<agent>.strategy from the firing device's config. Conflicts with an @version pin.`)
         .option('--balanced', 'Shortcut for --strategy balanced.')
         .option('--workflow <name>', 'Run an installed workflow (~/.agents/workflows/<name>) via `agents run`. Mutually exclusive with --agent.')
@@ -984,17 +985,26 @@ export function registerRoutinesCommands(program) {
             // silently missed a hard-deprecated harness pinned with @version.
             let parsedAgent;
             if (options.agent) {
-                const parsed = parseAgentVersionSpec(options.agent);
-                if ('error' in parsed) {
-                    console.error(chalk.red(parsed.error));
-                    process.exit(1);
+                // A custom harness (agents harness list) is a valid routine agent:
+                // the runner delegates it to `agents run <name>`. It pins its own
+                // host version, so no @version suffix applies (a suffixed name falls
+                // through to the parse error below).
+                if (isCustomHarnessName(options.agent)) {
+                    parsedAgent = { agent: options.agent };
                 }
-                parsedAgent = parsed;
-                // Hard-deprecated harnesses cannot be scheduled — refuse at create time
-                // so no new recurring job silently fails against a retired backend.
-                if (isAgentHardDeprecated(parsed.agent)) {
-                    console.error(chalk.red(hardDeprecationError(parsed.agent)));
-                    process.exit(1);
+                else {
+                    const parsed = parseAgentVersionSpec(options.agent);
+                    if ('error' in parsed) {
+                        console.error(chalk.red(parsed.error));
+                        process.exit(1);
+                    }
+                    parsedAgent = parsed;
+                    // Hard-deprecated harnesses cannot be scheduled — refuse at create time
+                    // so no new recurring job silently fails against a retired backend.
+                    if (isAgentHardDeprecated(parsed.agent)) {
+                        console.error(chalk.red(hardDeprecationError(parsed.agent)));
+                        process.exit(1);
+                    }
                 }
             }
             // --strategy / --balanced: per-routine selection policy, same vocabulary
@@ -1377,22 +1387,30 @@ export function registerRoutinesCommands(program) {
             if (options.projectAnchor !== undefined)
                 existing.project = options.projectAnchor;
             if (options.agent !== undefined) {
-                const parsed = parseAgentVersionSpec(options.agent);
-                if ('error' in parsed) {
-                    console.error(chalk.red(parsed.error));
-                    process.exit(1);
+                if (isCustomHarnessName(options.agent)) {
+                    // Custom harness: delegated to `agents run <name>`; the profile
+                    // pins its own host version, so any prior pin is cleared.
+                    existing.agent = options.agent;
+                    delete existing.version;
                 }
-                if (isAgentHardDeprecated(parsed.agent)) {
-                    console.error(chalk.red(hardDeprecationError(parsed.agent)));
-                    process.exit(1);
+                else {
+                    const parsed = parseAgentVersionSpec(options.agent);
+                    if ('error' in parsed) {
+                        console.error(chalk.red(parsed.error));
+                        process.exit(1);
+                    }
+                    if (isAgentHardDeprecated(parsed.agent)) {
+                        console.error(chalk.red(hardDeprecationError(parsed.agent)));
+                        process.exit(1);
+                    }
+                    existing.agent = parsed.agent;
+                    // An @version pin replaces any previous pin; a bare agent clears it so
+                    // the routine returns to strategy/balanced selection.
+                    if (parsed.version)
+                        existing.version = parsed.version;
+                    else
+                        delete existing.version;
                 }
-                existing.agent = parsed.agent;
-                // An @version pin replaces any previous pin; a bare agent clears it so
-                // the routine returns to strategy/balanced selection.
-                if (parsed.version)
-                    existing.version = parsed.version;
-                else
-                    delete existing.version;
             }
             if (options.strategy !== undefined) {
                 const normalized = normalizeRunStrategy(options.strategy);

package/dist/commands/run-account-picker.d.ts

@@ -12,10 +12,29 @@ export interface RunAccountChoice {
      */
     signInRequired: boolean;
 }
+/** One named account row for `agents accounts switch` (reuses this picker's layout). */
+export interface SwitchAccountRow {
+    accountName: string;
+    kind: 'provider' | 'native';
+    detail: string;
+    current: boolean;
+    candidate: RotateCandidate | null;
+}
 /** Human-readable remaining capacity for every window the provider exposes. */
 export declare function formatAccountLimits(candidate: RotateCandidate): string;
 /** Build aligned picker rows with usable accounts first and unsafe rows disabled. */
 export declare function buildRunAccountChoices(candidates: RotateCandidate[], globalDefault: string | null): RunAccountChoice[];
+/**
+ * Aligned picker rows for `accounts switch`. Same columns as the run picker
+ * (identity, status, limits) but the value is the named account to set-default.
+ * Rows stay selectable: setting a default is not a launch.
+ */
+export declare function buildSwitchAccountChoices(rows: SwitchAccountRow[]): RunAccountChoice[];
+/**
+ * Prompt for the named account that becomes this harness's default.
+ * A cancelled picker writes nothing.
+ */
+export declare function pickSwitchAccount(agent: AgentId, rows: SwitchAccountRow[]): Promise<string | null>;
 /**
  * Whether a zero-healthy run may recover by launching for a login, or must keep
  * failing loud. Three inputs, all of which have to hold:

package/dist/commands/run-account-picker.js

@@ -124,6 +124,87 @@ export function buildRunAccountChoices(candidates, globalDefault) {
         signInRequired: row.signInRequired,
     }));
 }
+function switchRowStatus(row) {
+    if (!row.candidate) {
+        return {
+            status: row.kind === 'provider' ? 'credential' : 'named',
+            limits: 'limits unavailable',
+            ready: true,
+        };
+    }
+    const readiness = readinessFromCandidate(row.candidate);
+    const authReason = readiness.ready ? null : readiness.reason;
+    const status = authReason === 'revoked'
+        ? 'needs re-login'
+        : authReason === 'signed_out'
+            ? 'logged out'
+            : authReason === 'rate_limited'
+                ? 'rate limited'
+                : authReason === 'out_of_credits'
+                    ? 'out of credits'
+                    : 'logged in';
+    const limits = authReason === 'revoked'
+        ? 'needs re-authentication'
+        : authReason === 'signed_out'
+            ? 'signed out'
+            : formatAccountLimits(row.candidate);
+    return { status, limits, ready: readiness.ready };
+}
+/**
+ * Aligned picker rows for `accounts switch`. Same columns as the run picker
+ * (identity, status, limits) but the value is the named account to set-default.
+ * Rows stay selectable: setting a default is not a launch.
+ */
+export function buildSwitchAccountChoices(rows) {
+    const rendered = rows.map((row) => {
+        const { status, limits, ready } = switchRowStatus(row);
+        const account = row.current ? `${row.accountName} (default)` : row.accountName;
+        const kind = row.kind === 'provider' ? `provider · ${row.detail}` : `native · ${row.detail}`;
+        return { account, kind, status, limits, ready, value: row.accountName };
+    });
+    const accountWidth = Math.max(0, ...rendered.map((row) => row.account.length));
+    const kindWidth = Math.max(0, ...rendered.map((row) => row.kind.length));
+    const statusWidth = Math.max(0, ...rendered.map((row) => row.status.length));
+    return rendered.map((row) => ({
+        name: [
+            row.account.padEnd(accountWidth),
+            row.kind.padEnd(kindWidth),
+            row.status.padEnd(statusWidth),
+            row.limits,
+        ].join('  '),
+        value: row.value,
+        ready: row.ready,
+        signInRequired: false,
+    }));
+}
+/**
+ * Prompt for the named account that becomes this harness's default.
+ * A cancelled picker writes nothing.
+ */
+export async function pickSwitchAccount(agent, rows) {
+    if (!isInteractiveTerminal()) {
+        requireInteractiveSelection(`Selecting a ${agentLabel(agent)} account`, [
+            `agents accounts switch ${agent} <account>`,
+            `agents accounts set-default ${agent} <account>`,
+        ]);
+    }
+    if (rows.length === 0) {
+        throw new Error(`No named accounts for ${agent}. Add one with 'agents accounts add <name> --provider <p>' or 'agents accounts name ${agent}@<version> <name>'.`);
+    }
+    const choices = buildSwitchAccountChoices(rows).map(({ ready: _ready, signInRequired: _signInRequired, ...choice }) => choice);
+    try {
+        return await select({
+            message: `Select the default ${agentLabel(agent)} account:`,
+            choices,
+            loop: false,
+        });
+    }
+    catch (err) {
+        if (isPromptCancelled(err))
+            return null;
+        throw err;
+    }
+}
 /**
  * Whether a zero-healthy run may recover by launching for a login, or must keep
  * failing loud. Three inputs, all of which have to hold:

package/dist/commands/sessions-picker-factory.d.ts

@@ -0,0 +1,40 @@
+/** Flag subset both twins share for the interactive-routing gate. */
+export interface SessionsPickerGateOpts {
+    interactive?: boolean;
+    json?: boolean;
+    /** Present only on the browser twin; computer never sets it. */
+    open?: string | boolean;
+}
+export interface SessionsPickerCommandSpec<TRow, TOpts extends SessionsPickerGateOpts> {
+    /**
+     * Browser requires `opts.open === undefined` so `--open` (bare or with a
+     * selector) falls through to the flat printer. Computer has no `--open`.
+     */
+    requireOpenUndefined?: boolean;
+    runFlat: (opts: TOpts) => void;
+    buildRows: (opts: TOpts) => TRow[];
+    emptyMessage: (opts: TOpts) => string;
+    message: string;
+    matches: (row: TRow, query: string) => boolean;
+    labelFor: (row: TRow) => string;
+    buildPreview: (row: TRow) => string;
+    emptyFilterMessage: string;
+    enterHint: string;
+    onOpen: (row: TRow) => void | Promise<void>;
+}
+export interface SessionsPickerCommand<TOpts extends SessionsPickerGateOpts> {
+    shouldOpen: (opts: TOpts, isTTY: boolean) => boolean;
+    run: (opts: TOpts) => Promise<void>;
+}
+export declare function shouldOpenInteractiveSessions(opts: SessionsPickerGateOpts, isTTY: boolean, requireOpenUndefined?: boolean): boolean;
+export declare function browseSessionsUntilQuit<TRow>(spec: {
+    message: string;
+    rows: TRow[];
+    matches: (row: TRow, query: string) => boolean;
+    labelFor: (row: TRow) => string;
+    buildPreview: (row: TRow) => string;
+    emptyFilterMessage: string;
+    enterHint: string;
+    onOpen: (row: TRow) => void | Promise<void>;
+}): Promise<void>;
+export declare function createSessionsPickerCommand<TRow, TOpts extends SessionsPickerGateOpts>(spec: SessionsPickerCommandSpec<TRow, TOpts>): SessionsPickerCommand<TOpts>;

package/dist/commands/sessions-picker-factory.js

@@ -0,0 +1,67 @@
+/**
+ * Shared interactive-routing + browse loop for the task-first session
+ * pickers (`browser-sessions-picker.ts`, `computer-sessions-picker.ts`).
+ *
+ * Each twin keeps its own row formatter, matcher, and enter-handler; this
+ * factory owns the TTY/`--json`/`--no-interactive` (and optional `--open`)
+ * gate, the empty-list message, and the cancel-aware `itemPicker` loop.
+ */
+import { itemPicker } from '../lib/picker.js';
+import { isInteractiveTerminal, isPromptCancelled } from './utils.js';
+export function shouldOpenInteractiveSessions(opts, isTTY, requireOpenUndefined = false) {
+    return (opts.interactive !== false &&
+        !opts.json &&
+        (!requireOpenUndefined || opts.open === undefined) &&
+        isTTY);
+}
+export async function browseSessionsUntilQuit(spec) {
+    for (;;) {
+        let picked;
+        try {
+            picked = await itemPicker({
+                message: spec.message,
+                items: spec.rows,
+                filter: (query) => (query.trim() ? spec.rows.filter((r) => spec.matches(r, query)) : spec.rows),
+                labelFor: spec.labelFor,
+                buildPreview: spec.buildPreview,
+                emptyMessage: spec.emptyFilterMessage,
+                enterHint: spec.enterHint,
+            });
+        }
+        catch (err) {
+            if (isPromptCancelled(err))
+                return;
+            throw err;
+        }
+        if (!picked)
+            return;
+        await spec.onOpen(picked.item);
+    }
+}
+export function createSessionsPickerCommand(spec) {
+    const shouldOpen = (opts, isTTY) => shouldOpenInteractiveSessions(opts, isTTY, spec.requireOpenUndefined === true);
+    return {
+        shouldOpen,
+        run: async (opts) => {
+            if (!shouldOpen(opts, isInteractiveTerminal())) {
+                spec.runFlat(opts);
+                return;
+            }
+            const rows = spec.buildRows(opts);
+            if (rows.length === 0) {
+                console.log(spec.emptyMessage(opts));
+                return;
+            }
+            await browseSessionsUntilQuit({
+                message: spec.message,
+                rows,
+                matches: spec.matches,
+                labelFor: spec.labelFor,
+                buildPreview: spec.buildPreview,
+                emptyFilterMessage: spec.emptyFilterMessage,
+                enterHint: spec.enterHint,
+                onOpen: spec.onOpen,
+            });
+        },
+    };
+}