@parall/cli 1.22.0 → 1.24.0

package/dist/commands/agents.d.ts

@@ -1,3 +1,48 @@
 import { Command } from 'commander';
+import type { AgentPresence, CreateAgentResponse, Machine, ParallClient } from '@parall/sdk';
+export declare function validateMachineOptions(opts: {
+    machineType?: string;
+    machineLabel?: string;
+    cpuCores?: number;
+    memoryMB?: number;
+    storageGB?: number;
+}): void;
+export declare function validateApiKeyOutputOptions(opts: {
+    apiKeyFile?: string;
+    showApiKey?: boolean;
+    discardApiKey?: boolean;
+    machineType?: string;
+}): void;
+export declare function validateWaitOptions(opts: {
+    wait?: boolean;
+    waitOnline?: boolean;
+    machineType?: string;
+}): void;
+export declare function redactCreateAgentResponse(result: CreateAgentResponse, opts: {
+    apiKeyFile?: string;
+    discardApiKey?: boolean;
+}): Partial<{
+    api_key_redacted: boolean;
+    api_key_file: string | undefined;
+    api_key_discarded: boolean | undefined;
+    user: import("@parall/sdk").User;
+    machine?: Machine;
+}>;
+export declare class ProvisioningWaitError extends Error {
+    readonly phase: 'machine' | 'agent_online';
+    readonly state?: string;
+    constructor(message: string, phase: 'machine' | 'agent_online', state?: string);
+}
+export declare function waitForMachineRunning(client: ParallClient, orgId: string, machineId: string, opts: {
+    deadline: number;
+    intervalMs: number;
+}): Promise<{
+    state: string;
+    machine: Machine;
+}>;
+export declare function waitForAgentOnline(client: ParallClient, orgId: string, agentId: string, opts: {
+    deadline: number;
+    intervalMs: number;
+}): Promise<AgentPresence>;
 export declare function registerAgentCommands(program: Command): void;
 //# sourceMappingURL=agents.d.ts.map

package/dist/commands/agents.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/commands/agents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,QAerD"}
+{"version":3,"file":"agents.d.ts","sourceRoot":"","sources":["../../src/commands/agents.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,KAAK,EAAE,aAAa,EAAsB,mBAAmB,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAgCjH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,QAgBA;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE;IAChD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,QAWA;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,UAAU,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,QAIvG;AAuBD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,mBAAmB,EAAE,IAAI,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,OAAO,CAAA;CAAE;;;;;;GAQ5H;AAMD,qBAAa,qBAAsB,SAAQ,KAAK;IAC9C,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,cAAc,CAAC;IAC3C,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;gBAEZ,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,cAAc,EAAE,KAAK,CAAC,EAAE,MAAM;CAM/E;AAQD,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC7C,OAAO,CAAC;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAc9C;AAED,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,IAAI,EAAE;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAC7C,OAAO,CAAC,aAAa,CAAC,CASxB;AA4CD,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,QAoIrD"}

package/dist/commands/agents.js

@@ -1,5 +1,172 @@
+import { closeSync, openSync, unlinkSync, writeFileSync } from 'node:fs';
 import { resolveCredentials } from '../lib/client.js';
-import { printJson, printError } from '../lib/output.js';
+import { printJson, printError, printRefHint } from '../lib/output.js';
+function stripUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+}
+function parseOptionalInt(value, field) {
+    if (value === undefined)
+        return undefined;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${field} must be a positive integer`);
+    }
+    return parsed;
+}
+function parsePermissions(value) {
+    if (!value)
+        return undefined;
+    const permissions = value.split(',').map((v) => v.trim()).filter(Boolean);
+    return permissions.length > 0 ? permissions : undefined;
+}
+function parseOptionalSeconds(value, field, fallback) {
+    if (value === undefined)
+        return fallback;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${field} must be a positive integer`);
+    }
+    return parsed;
+}
+export function validateMachineOptions(opts) {
+    const hasCustomSpec = opts.cpuCores !== undefined || opts.memoryMB !== undefined || opts.storageGB !== undefined;
+    if (opts.machineLabel !== undefined && opts.machineType !== 'cloud') {
+        throw new Error('--machine-label requires --machine-type cloud');
+    }
+    if (hasCustomSpec && opts.machineType !== 'cloud') {
+        throw new Error('cpu-cores/memory-mb/storage-gb require --machine-type cloud');
+    }
+    if (hasCustomSpec && opts.machineLabel !== 'custom') {
+        throw new Error('cpu-cores/memory-mb/storage-gb require --machine-label custom');
+    }
+    if (opts.machineType === 'cloud' && opts.machineLabel === 'custom') {
+        if (opts.cpuCores === undefined || opts.memoryMB === undefined || opts.storageGB === undefined) {
+            throw new Error('custom machine requires --cpu-cores --memory-mb --storage-gb');
+        }
+    }
+}
+export function validateApiKeyOutputOptions(opts) {
+    const selected = [opts.apiKeyFile !== undefined, opts.showApiKey === true, opts.discardApiKey === true].filter(Boolean).length;
+    if (selected > 1) {
+        throw new Error('--api-key-file, --show-api-key, and --discard-api-key are mutually exclusive');
+    }
+    if (selected === 0) {
+        throw new Error('choose --api-key-file <path>, --show-api-key, or --discard-api-key for the one-time api_key');
+    }
+    if (opts.discardApiKey && opts.machineType !== 'cloud') {
+        throw new Error('--discard-api-key requires --machine-type cloud because self-hosted agents need the one-time api_key');
+    }
+}
+export function validateWaitOptions(opts) {
+    if ((opts.wait || opts.waitOnline) && opts.machineType !== 'cloud') {
+        throw new Error('--wait and --wait-online require --machine-type cloud');
+    }
+}
+function writeApiKeyFile(fd, apiKey) {
+    writeFileSync(fd, `${apiKey}\n`, { encoding: 'utf8' });
+    closeSync(fd);
+}
+function cleanupApiKeyFile(fd, path) {
+    if (fd === undefined)
+        return;
+    try {
+        closeSync(fd);
+    }
+    catch {
+        // best-effort cleanup
+    }
+    if (path) {
+        try {
+            unlinkSync(path);
+        }
+        catch {
+            // best-effort cleanup
+        }
+    }
+}
+export function redactCreateAgentResponse(result, opts) {
+    const { api_key: _apiKey, ...safeResult } = result;
+    return stripUndefined({
+        ...safeResult,
+        api_key_redacted: true,
+        api_key_file: opts.apiKeyFile,
+        api_key_discarded: opts.discardApiKey === true ? true : undefined,
+    });
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export class ProvisioningWaitError extends Error {
+    phase;
+    state;
+    constructor(message, phase, state) {
+        super(message);
+        this.name = 'ProvisioningWaitError';
+        this.phase = phase;
+        this.state = state;
+    }
+}
+function ensureTimeRemaining(deadline, label, phase, state) {
+    if (Date.now() >= deadline) {
+        throw new ProvisioningWaitError(`${label} timed out`, phase, state);
+    }
+}
+export async function waitForMachineRunning(client, orgId, machineId, opts) {
+    let lastState = 'unknown';
+    for (;;) {
+        ensureTimeRemaining(opts.deadline, 'machine provisioning', 'machine', lastState === 'unknown' ? undefined : lastState);
+        const status = await client.getMachineStatus(orgId, machineId);
+        lastState = status.state;
+        if (lastState === 'running') {
+            return { state: lastState, machine: await client.getMachine(orgId, machineId) };
+        }
+        if (lastState === 'error' || lastState === 'terminated' || lastState === 'stopped') {
+            throw new ProvisioningWaitError(`machine provisioning ended with state ${lastState}`, 'machine', lastState);
+        }
+        await sleep(Math.min(opts.intervalMs, Math.max(0, opts.deadline - Date.now())));
+    }
+}
+export async function waitForAgentOnline(client, orgId, agentId, opts) {
+    for (;;) {
+        ensureTimeRemaining(opts.deadline, 'agent online wait', 'agent_online');
+        const presence = parseAgentMonitor(await client.getAgentMonitor(orgId, agentId));
+        if (presence.online) {
+            return presence;
+        }
+        await sleep(Math.min(opts.intervalMs, Math.max(0, opts.deadline - Date.now())));
+    }
+}
+function parseAgentMonitor(raw) {
+    if (raw === null || typeof raw !== 'object') {
+        return { online: false, status: 'offline' };
+    }
+    const data = raw;
+    const online = data.online === true;
+    return stripUndefined({
+        online,
+        status: typeof data.status === 'string' ? data.status : online ? 'online' : 'offline',
+        session_id: typeof data.session_id === 'string' ? data.session_id : undefined,
+        telemetry: data.telemetry !== null && typeof data.telemetry === 'object'
+            ? data.telemetry
+            : undefined,
+    });
+}
+function createAgentOutput(result, opts) {
+    return opts.showApiKey
+        ? result
+        : redactCreateAgentResponse(result, {
+            apiKeyFile: opts.apiKeyFile,
+            discardApiKey: opts.discardApiKey,
+        });
+}
+function printCreateAgentResult(result, opts, provisioning) {
+    const output = createAgentOutput(result, opts);
+    printJson(Object.keys(provisioning).length > 0 ? { ...output, provisioning } : output);
+    printRefHint(result.user.id);
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
 export function registerAgentCommands(program) {
     const agents = program.command('agents').description('Manage agents');
     agents
@@ -15,4 +182,122 @@ export function registerAgentCommands(program) {
             printError(err);
         }
     });
+    agents
+        .command('create')
+        .description('Create an agent in the organization')
+        .requiredOption('--name <name>', 'Agent display name')
+        .option('--runtime-type <type>', 'Runtime type: openclaw, claude-code, codex, hermes')
+        .option('--machine-type <type>', 'Machine type. Use "cloud" to provision hosted compute')
+        .option('--machine-label <label>', 'Hosted preset: lite, standard, pro, or custom')
+        .option('--cpu-cores <n>', 'CPU cores for machine-label=custom')
+        .option('--memory-mb <n>', 'Memory in MiB for machine-label=custom')
+        .option('--storage-gb <n>', 'Storage in GiB for machine-label=custom')
+        .option('--model-management <mode>', 'Model management mode: platform or self')
+        .option('--agent-model <model>', 'Platform-assigned model')
+        .option('--agent-provider <provider>', 'Agent provider metadata')
+        .option('--agent-endpoint <endpoint>', 'Agent endpoint metadata')
+        .option('--agent-permissions <permissions>', 'Comma-separated agent permissions')
+        .option('--openai-api-key <key>', 'Hosted Codex OpenAI API key override')
+        .option('--openai-base-url <url>', 'Hosted Codex OpenAI-compatible base URL override')
+        .option('--api-key-file <path>', 'Write the one-time API key to a new 0600 file')
+        .option('--show-api-key', 'Print the one-time API key to stdout; unsafe in logged agent runtimes')
+        .option('--discard-api-key', 'Discard the one-time API key; use for cloud agents where the server injects it')
+        .option('--wait', 'For cloud agents, wait until the machine reaches running')
+        .option('--wait-online', 'Wait until the created agent reports online presence; implies --wait for cloud agents')
+        .option('--wait-timeout-sec <n>', 'Maximum seconds to wait for provisioning/online status', '600')
+        .option('--wait-interval-sec <n>', 'Seconds between status polls', '5')
+        .action(async (opts) => {
+        let apiKeyFileFd;
+        try {
+            const { client, orgId } = resolveCredentials();
+            const cpuCores = parseOptionalInt(opts.cpuCores, 'cpu-cores');
+            const memoryMB = parseOptionalInt(opts.memoryMb, 'memory-mb');
+            const storageGB = parseOptionalInt(opts.storageGb, 'storage-gb');
+            validateApiKeyOutputOptions({
+                apiKeyFile: opts.apiKeyFile,
+                showApiKey: opts.showApiKey,
+                discardApiKey: opts.discardApiKey,
+                machineType: opts.machineType,
+            });
+            validateMachineOptions({
+                machineType: opts.machineType,
+                machineLabel: opts.machineLabel,
+                cpuCores,
+                memoryMB,
+                storageGB,
+            });
+            validateWaitOptions({
+                wait: opts.wait,
+                waitOnline: opts.waitOnline,
+                machineType: opts.machineType,
+            });
+            const waitTimeoutSec = parseOptionalSeconds(opts.waitTimeoutSec, 'wait-timeout-sec', 600);
+            const waitIntervalSec = parseOptionalSeconds(opts.waitIntervalSec, 'wait-interval-sec', 5);
+            if (opts.apiKeyFile) {
+                apiKeyFileFd = openSync(opts.apiKeyFile, 'wx', 0o600);
+            }
+            const providerConfig = stripUndefined({
+                openai_api_key: opts.openaiApiKey,
+                openai_base_url: opts.openaiBaseUrl,
+            });
+            const req = stripUndefined({
+                display_name: opts.name,
+                runtime_type: opts.runtimeType,
+                machine_type: opts.machineType,
+                machine_label: opts.machineLabel,
+                cpu_cores: cpuCores,
+                memory_mb: memoryMB,
+                storage_gb: storageGB,
+                model_management: opts.modelManagement,
+                agent_model: opts.agentModel,
+                agent_provider: opts.agentProvider,
+                agent_endpoint: opts.agentEndpoint,
+                agent_permissions: parsePermissions(opts.agentPermissions),
+                provider_config: Object.keys(providerConfig).length > 0 ? providerConfig : undefined,
+            });
+            const result = await client.createAgent(orgId, req);
+            if (apiKeyFileFd !== undefined) {
+                writeApiKeyFile(apiKeyFileFd, result.api_key);
+                apiKeyFileFd = undefined;
+            }
+            const waitDeadline = Date.now() + waitTimeoutSec * 1000;
+            const provisioning = {};
+            try {
+                const shouldWaitMachine = opts.wait || opts.waitOnline;
+                if (shouldWaitMachine && result.machine) {
+                    const waited = await waitForMachineRunning(client, orgId, result.machine.id, {
+                        deadline: waitDeadline,
+                        intervalMs: waitIntervalSec * 1000,
+                    });
+                    result.machine = waited.machine;
+                    provisioning.machine_state = waited.state;
+                }
+                if (opts.waitOnline) {
+                    const presence = await waitForAgentOnline(client, orgId, result.user.id, {
+                        deadline: waitDeadline,
+                        intervalMs: waitIntervalSec * 1000,
+                    });
+                    provisioning.agent_online = true;
+                    provisioning.presence = presence;
+                }
+            }
+            catch (waitErr) {
+                provisioning.wait_failed = true;
+                provisioning.wait_error = errorMessage(waitErr);
+                if (waitErr instanceof ProvisioningWaitError) {
+                    provisioning.wait_phase = waitErr.phase;
+                    if (waitErr.state) {
+                        provisioning.last_state = waitErr.state;
+                    }
+                }
+                printCreateAgentResult(result, opts, provisioning);
+                printError(waitErr);
+            }
+            printCreateAgentResult(result, opts, provisioning);
+        }
+        catch (err) {
+            cleanupApiKeyFile(apiKeyFileFd, opts.apiKeyFile);
+            printError(err);
+        }
+    });
 }

package/dist/commands/approvals.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerApprovalCommands(program: Command): void;
+//# sourceMappingURL=approvals.d.ts.map

package/dist/commands/approvals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"approvals.d.ts","sourceRoot":"","sources":["../../src/commands/approvals.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,OAAO,QAgExD"}

package/dist/commands/approvals.js

@@ -0,0 +1,67 @@
+import { resolveCredentials } from '../lib/client.js';
+import { printJson, printError, printRefHint, stripPrllScheme } from '../lib/output.js';
+export function registerApprovalCommands(program) {
+    const approvals = program.command('approvals').description('Manage approval requests');
+    approvals
+        .command('request')
+        .description('Request approval for a permission-denied action')
+        .requiredOption('--action <type>', 'Action type (e.g. chat.archive)')
+        .requiredOption('--resource <uri>', 'Resource URI (e.g. prll://cht_123)')
+        .requiredOption('--chat <chatId>', 'Chat to post the approval card in (e.g. prll://cht_456)')
+        .requiredOption('--title <title>', 'Human-readable title for the request')
+        .option('--reason <text>', 'Why this action is needed')
+        .option('--payload <json>', 'Frozen action payload as a JSON object')
+        .action(async (opts) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            let actionPayload;
+            if (opts.payload) {
+                const parsed = JSON.parse(opts.payload);
+                if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                    throw new Error('--payload must be a JSON object');
+                }
+                actionPayload = parsed;
+            }
+            const result = await client.requestApproval(orgId, {
+                action_type: opts.action,
+                resource_uri: opts.resource,
+                action_payload: actionPayload,
+                chat_id: stripPrllScheme(opts.chat),
+                title: opts.title,
+                reason: opts.reason,
+            });
+            printJson(result);
+            printRefHint(result.id);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    approvals
+        .command('cancel')
+        .description('Cancel a pending approval request')
+        .argument('<approvalId>', 'Approval request ID')
+        .action(async (approvalId) => {
+        try {
+            const { client } = resolveCredentials();
+            await client.cancelApproval(stripPrllScheme(approvalId));
+            printJson({ ok: true, id: stripPrllScheme(approvalId), status: 'cancelled' });
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    approvals
+        .command('list')
+        .description('List pending approval requests')
+        .action(async () => {
+        try {
+            const { client } = resolveCredentials();
+            const result = await client.getPendingApprovals();
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+}

package/dist/commands/machines.d.ts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+export declare function registerMachineCommands(program: Command): void;
+//# sourceMappingURL=machines.d.ts.map

package/dist/commands/machines.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"machines.d.ts","sourceRoot":"","sources":["../../src/commands/machines.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,QA0DvD"}

package/dist/commands/machines.js

@@ -0,0 +1,70 @@
+import { resolveCredentials } from '../lib/client.js';
+import { printJson, printError, stripPrllScheme } from '../lib/output.js';
+function parseLines(value) {
+    if (value === undefined)
+        return 100;
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error('lines must be a positive integer');
+    }
+    return parsed;
+}
+export function registerMachineCommands(program) {
+    const machines = program.command('machines').description('Inspect hosted agent machines');
+    machines
+        .command('list')
+        .description('List machines in the organization')
+        .action(async () => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            const result = await client.getMachines(orgId);
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    machines
+        .command('get')
+        .description('Get a machine by ID')
+        .argument('<machineId>', 'Machine ID')
+        .action(async (machineId) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            const result = await client.getMachine(orgId, stripPrllScheme(machineId));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    machines
+        .command('status')
+        .description('Get current machine status')
+        .argument('<machineId>', 'Machine ID')
+        .action(async (machineId) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            const result = await client.getMachineStatus(orgId, stripPrllScheme(machineId));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    machines
+        .command('logs')
+        .description('Get recent machine logs')
+        .argument('<machineId>', 'Machine ID')
+        .option('--lines <n>', 'Number of log lines', '100')
+        .action(async (machineId, opts) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            const result = await client.getMachineLogs(orgId, stripPrllScheme(machineId), parseLines(opts.lines));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+}

package/dist/commands/schedules.js

@@ -11,7 +11,7 @@ export function registerScheduleCommands(program) {
         .command('list')
         .description('List schedules in the organization')
         .option('--attached-to <uri>', 'Filter by attached prll:// URI (exact match)')
-        .option('--target-id <id>', 'Filter by target user ID')
+        .option('--attendee-id <id>', 'Filter by attendee user ID')
         .option('--creator-id <id>', 'Filter by creator user ID')
         .option('--status <statuses>', 'Comma-separated statuses (e.g. active,paused)')
         .option('--limit <n>', 'Maximum number of schedules to return', '50')
@@ -21,7 +21,7 @@ export function registerScheduleCommands(program) {
             const { client, orgId } = resolveCredentials();
             const params = stripUndefined({
                 attached_to: opts.attachedTo,
-                target_id: opts.targetId ? stripPrllScheme(opts.targetId) : undefined,
+                attendee_id: opts.attendeeId ? stripPrllScheme(opts.attendeeId) : undefined,
                 creator_id: opts.creatorId ? stripPrllScheme(opts.creatorId) : undefined,
                 status: opts.status,
                 limit: Number(opts.limit),
@@ -39,7 +39,7 @@ export function registerScheduleCommands(program) {
         .description('Create a schedule. Provide exactly one of --cron-expr, --interval-seconds, or --run-at.')
         .requiredOption('--name <name>', 'Schedule name')
         .requiredOption('--description <text>', 'Message delivered to the target on fire')
-        .requiredOption('--target-id <id>', 'Target user ID (agent or human)')
+        .requiredOption('--target-ids <ids>', 'Comma-separated target user IDs (agents or humans)')
         .option('--spec-type <type>', 'cron | interval | one_shot (inferred from spec flags if omitted)')
         .option('--cron-expr <expr>', '5-field cron expression')
         .option('--interval-seconds <n>', 'Interval in seconds (>= 60)')
@@ -67,7 +67,7 @@ export function registerScheduleCommands(program) {
             const data = {
                 name: opts.name,
                 description: opts.description,
-                target_id: stripPrllScheme(opts.targetId),
+                target_ids: opts.targetIds.split(',').map((s) => stripPrllScheme(s.trim())).filter(Boolean),
                 spec_type: specType,
                 ...stripUndefined({
                     attached_to_uri: opts.attachedToUri,
@@ -109,7 +109,7 @@ export function registerScheduleCommands(program) {
         .argument('<scheduleId>', 'Schedule ID')
         .option('--name <name>', 'Schedule name')
         .option('--description <text>', 'Message delivered to the target on fire')
-        .option('--target-id <id>', 'Target user ID')
+        .option('--target-ids <ids>', 'Comma-separated target user IDs')
         .option('--attached-to-uri <uri>', 'Attach to a prll:// resource URI')
         .option('--clear-attached-to', 'Explicitly clear attached_to_uri')
         .option('--cron-expr <expr>', '5-field cron expression')
@@ -147,7 +147,7 @@ export function registerScheduleCommands(program) {
             const data = stripUndefined({
                 name: opts.name,
                 description: opts.description,
-                target_id: opts.targetId ? stripPrllScheme(opts.targetId) : undefined,
+                target_ids: opts.targetIds ? opts.targetIds.split(',').map((s) => stripPrllScheme(s.trim())).filter(Boolean) : undefined,
                 attached_to_uri: opts.attachedToUri,
                 attached_to_uri_clear: opts.clearAttachedTo || undefined,
                 cron_expr: opts.cronExpr,

package/dist/index.js

@@ -2,6 +2,7 @@
 import { createRequire } from 'module';
 import { Command } from 'commander';
 import { registerAgentCommands } from './commands/agents.js';
+import { registerApprovalCommands } from './commands/approvals.js';
 import { registerChatCommands } from './commands/chats.js';
 import { registerDMCommands } from './commands/dm.js';
 import { registerMessageCommands } from './commands/messages.js';
@@ -14,6 +15,7 @@ import { registerMcpCommands } from './commands/mcp.js';
 import { registerNoReplyCommands } from './commands/no-reply.js';
 import { registerRefCommands } from './commands/refs.js';
 import { registerFileCommands } from './commands/files.js';
+import { registerMachineCommands } from './commands/machines.js';
 const require = createRequire(import.meta.url);
 const pkg = require('../package.json');
 const program = new Command();
@@ -22,6 +24,7 @@ program
     .description('CLI client for Parall — universal agent & human access to Parall API')
     .version(pkg.version);
 registerAgentCommands(program);
+registerApprovalCommands(program);
 registerChatCommands(program);
 registerDMCommands(program);
 registerMessageCommands(program);
@@ -34,4 +37,5 @@ registerMcpCommands(program);
 registerNoReplyCommands(program);
 registerRefCommands(program);
 registerFileCommands(program);
+registerMachineCommands(program);
 program.parse();

package/dist/lib/output.js

@@ -19,7 +19,7 @@ export function stripPrllScheme(idOrUri) {
 export function printError(err) {
     let msg;
     if (err instanceof ApiError) {
-        msg = { error: err.message, status: err.status };
+        msg = { error: err.message, status: err.status, ...(err.code ? { code: err.code } : {}) };
     }
     else if (err instanceof Error) {
         msg = { error: err.message };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@parall/cli",
-  "version": "1.22.0",
+  "version": "1.24.0",
   "description": "CLI client for Parall — universal agent & human access to Parall API",
   "license": "MIT",
   "repository": {
@@ -30,7 +30,7 @@
     "@modelcontextprotocol/sdk": "1.27.1",
     "commander": "^13.0.0",
     "zod": "^4.3.6",
-    "@parall/sdk": "1.22.0"
+    "@parall/sdk": "1.24.0"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",