@parall/cli 1.35.0 → 1.36.1

package/dist/commands/external-triggers.d.ts

@@ -0,0 +1,19 @@
+import type { ExternalConnection } from '@parall/sdk';
+import type { Command } from 'commander';
+export declare const EXTERNAL_TRIGGERS_FLAG = "external-triggers";
+type ExternalTriggerFeatureFlagClient = {
+    getFeatureFlags(orgId: string): Promise<{
+        flags: Record<string, boolean | string | number>;
+    }>;
+};
+type IngressTokenOutputOptions = {
+    tokenFile?: string;
+    showToken?: boolean;
+};
+export declare function isFeatureFlagEnabled(value: boolean | string | number | undefined): boolean;
+export declare function requireExternalTriggersEnabled(client: ExternalTriggerFeatureFlagClient, orgId: string): Promise<void>;
+export declare function validateIngressTokenOutputOptions(opts: IngressTokenOutputOptions): void;
+export declare function connectionTokenOutput(connection: ExternalConnection, opts: IngressTokenOutputOptions): Promise<ExternalConnection | Record<string, unknown>>;
+export declare function registerExternalTriggerCommands(program: Command): void;
+export {};
+//# sourceMappingURL=external-triggers.d.ts.map

package/dist/commands/external-triggers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-triggers.d.ts","sourceRoot":"","sources":["../../src/commands/external-triggers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,kBAAkB,EAInB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMzC,eAAO,MAAM,sBAAsB,sBAAsB,CAAC;AAE1D,KAAK,gCAAgC,GAAG;IACtC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC,CAAA;KAAE,CAAC,CAAC;CAC/F,CAAC;AAEF,KAAK,yBAAyB,GAAG;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAsDF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAM1F;AAED,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,gCAAgC,EACxC,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAKf;AAQD,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,yBAAyB,GAAG,IAAI,CAKvF;AAED,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,kBAAkB,EAC9B,IAAI,EAAE,yBAAyB,GAC9B,OAAO,CAAC,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAqBvD;AAkBD,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,OAAO,QAqZ/D"}

package/dist/commands/external-triggers.js

@@ -0,0 +1,488 @@
+import { chmod, readFile, writeFile } from 'node:fs/promises';
+import { resolveCredentials } from '../lib/client.js';
+import { printError, printJson, printRefHint, stripPrllScheme } from '../lib/output.js';
+const connectionStatuses = ['active', 'disabled'];
+const triggerStatuses = ['active', 'paused'];
+export const EXTERNAL_TRIGGERS_FLAG = 'external-triggers';
+function stripUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+}
+function parseIds(value, flag) {
+    const ids = value
+        .split(',')
+        .map((s) => stripPrllScheme(s.trim()))
+        .filter(Boolean);
+    if (ids.length === 0) {
+        throw new Error(`${flag} must include at least one ID.`);
+    }
+    return ids;
+}
+function parsePositiveInt(value, flag) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim();
+    const parsed = Number(normalized);
+    if (normalized === '' || !Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${flag} must be a positive integer.`);
+    }
+    return parsed;
+}
+function parseEnum(value, allowed, flag) {
+    if (value === undefined)
+        return undefined;
+    if (allowed.includes(value))
+        return value;
+    throw new Error(`${flag} must be one of: ${allowed.join(', ')}.`);
+}
+function parseJsonObject(value, flag) {
+    if (value === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new Error(`${flag} must be a valid JSON object.`);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${flag} must be a JSON object.`);
+    }
+    return parsed;
+}
+export function isFeatureFlagEnabled(value) {
+    return (value === true ||
+        (typeof value === 'string' && value !== '') ||
+        (typeof value === 'number' && value !== 0));
+}
+export async function requireExternalTriggersEnabled(client, orgId) {
+    const res = await client.getFeatureFlags(orgId);
+    if (!isFeatureFlagEnabled(res.flags[EXTERNAL_TRIGGERS_FLAG])) {
+        throw new Error('External Triggers are disabled for this organization.');
+    }
+}
+async function resolveExternalTriggerCommandContext() {
+    const ctx = resolveCredentials();
+    await requireExternalTriggersEnabled(ctx.client, ctx.orgId);
+    return ctx;
+}
+export function validateIngressTokenOutputOptions(opts) {
+    const count = [opts.tokenFile, opts.showToken].filter(Boolean).length;
+    if (count !== 1) {
+        throw new Error('Choose exactly one token output mode: --token-file <path> or --show-token.');
+    }
+}
+export async function connectionTokenOutput(connection, opts) {
+    validateIngressTokenOutputOptions(opts);
+    if (!connection.ingress_token) {
+        throw new Error('Server did not return an ingress token.');
+    }
+    if (opts.showToken)
+        return connection;
+    if (!opts.tokenFile) {
+        throw new Error('Choose exactly one token output mode: --token-file <path> or --show-token.');
+    }
+    await writeFile(opts.tokenFile, connection.ingress_token, { mode: 0o600 });
+    await chmod(opts.tokenFile, 0o600);
+    const redacted = { ...connection };
+    delete redacted.ingress_token;
+    delete redacted.ingress_url;
+    return {
+        ...redacted,
+        ingress_token_redacted: true,
+        ingress_url_redacted: true,
+        ingress_token_file: opts.tokenFile,
+    };
+}
+async function resolveTemplate(opts) {
+    if (opts.template !== undefined && opts.templateFile !== undefined) {
+        throw new Error('Do not pass --template together with --template-file.');
+    }
+    if (opts.templateFile !== undefined) {
+        return readFile(opts.templateFile, 'utf8');
+    }
+    if (opts.template !== undefined)
+        return opts.template;
+    if (opts.required)
+        throw new Error('Provide --template or --template-file.');
+    return undefined;
+}
+export function registerExternalTriggerCommands(program) {
+    const externalTriggers = program
+        .command('external-triggers')
+        .description('Manage External Triggers (incoming platform triggers for agents)');
+    externalTriggers
+        .command('connections')
+        .description('List External Trigger Connections in the organization')
+        .option('--limit <n>', 'Maximum number of connections to return', '50')
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .action(async (opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.listExternalConnections(orgId, stripUndefined({
+                limit: parsePositiveInt(opts.limit, '--limit'),
+                cursor: opts.cursor,
+            }));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('create-connection')
+        .description('Create an External Trigger Connection and return its incoming endpoint')
+        .requiredOption('--name <name>', 'Connection display name')
+        .option('--token-file <path>', 'Write the one-time token to a file with mode 0600')
+        .option('--show-token', 'Print the one-time token to stdout')
+        .action(async (opts) => {
+        try {
+            validateIngressTokenOutputOptions(opts);
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.createExternalConnection(orgId, {
+                display_name: opts.name,
+            });
+            printJson(await connectionTokenOutput(result, opts));
+            printRefHint(result.id);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('connection')
+        .description('Get an External Trigger Connection by ID')
+        .argument('<connectionId>', 'External Trigger Connection ID')
+        .action(async (connectionId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.getExternalConnection(orgId, stripPrllScheme(connectionId));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('update-connection')
+        .description('Update an External Trigger Connection')
+        .argument('<connectionId>', 'External Trigger Connection ID')
+        .option('--name <name>', 'Connection display name')
+        .option('--status <status>', 'active | disabled')
+        .action(async (connectionId, opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const patch = stripUndefined({
+                display_name: opts.name,
+                status: parseEnum(opts.status, connectionStatuses, '--status'),
+            });
+            if (Object.keys(patch).length === 0) {
+                printError(new Error('No fields to update. Provide at least one option.'));
+                return;
+            }
+            const result = await client.updateExternalConnection(orgId, stripPrllScheme(connectionId), patch);
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('regenerate-connection-token')
+        .description('Regenerate a connection ingress token; old webhook URLs stop working')
+        .argument('<connectionId>', 'External Trigger Connection ID')
+        .option('--token-file <path>', 'Write the one-time token to a file with mode 0600')
+        .option('--show-token', 'Print the one-time token to stdout')
+        .action(async (connectionId, opts) => {
+        try {
+            validateIngressTokenOutputOptions(opts);
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.regenerateExternalConnectionIngressToken(orgId, stripPrllScheme(connectionId));
+            printJson(await connectionTokenOutput(result, opts));
+            printRefHint(result.id, 'Regenerated');
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('delete-connection')
+        .description('Archive an External Trigger Connection')
+        .argument('<connectionId>', 'External Trigger Connection ID')
+        .action(async (connectionId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            await client.deleteExternalConnection(orgId, stripPrllScheme(connectionId));
+            printJson({ ok: true });
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('schema')
+        .description('Inspect CEL/template variables supported by a connection')
+        .argument('<connectionId>', 'External Trigger Connection ID')
+        .action(async (connectionId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.getExternalTriggerSchema(orgId, stripPrllScheme(connectionId));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('list')
+        .description('List External Triggers in the organization')
+        .option('--connection <connectionId>', 'Filter by External Trigger Connection ID')
+        .option('--creator-id <id>', 'Filter by creator user ID')
+        .option('--limit <n>', 'Maximum number of triggers to return', '50')
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .action(async (opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.listExternalTriggers(orgId, stripUndefined({
+                connection_id: opts.connection ? stripPrllScheme(opts.connection) : undefined,
+                creator_id: opts.creatorId ? stripPrllScheme(opts.creatorId) : undefined,
+                limit: parsePositiveInt(opts.limit, '--limit'),
+                cursor: opts.cursor,
+            }));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('create')
+        .description('Create an External Trigger targeting one or more agents')
+        .requiredOption('--connection <connectionId>', 'External Trigger Connection ID')
+        .requiredOption('--name <name>', 'Trigger name')
+        .requiredOption('--target-ids <ids>', 'Comma-separated target agent user IDs')
+        .option('--description <text>', 'Human-facing trigger description')
+        .option('--attached-to-uri <uri>', 'Attach to a prll:// resource URI')
+        .option('--filter <expr>', 'CEL filter expression', 'true')
+        .option('--filter-metadata-json <json>', 'JSON object with UI/display metadata for the filter')
+        .option('--template <text>', 'Liquid template for the agent input body')
+        .option('--template-file <path>', 'Read the Liquid template from a file')
+        .option('--max-runs <n>', 'Maximum delivered runs before the trigger auto-archives')
+        .option('--expires-at <ts>', 'Expiration time (RFC3339)')
+        .option('--client-context-json <json>', 'JSON object stored with the trigger')
+        .action(async (opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const agentInputTemplate = await resolveTemplate({ ...opts, required: true });
+            const data = {
+                connection_id: stripPrllScheme(opts.connection),
+                name: opts.name,
+                target_agent_ids: parseIds(opts.targetIds, '--target-ids'),
+                filter_expr: opts.filter,
+                agent_input_template: agentInputTemplate ?? '',
+                ...stripUndefined({
+                    description: opts.description,
+                    attached_to_uri: opts.attachedToUri,
+                    filter_display_metadata: parseJsonObject(opts.filterMetadataJson, '--filter-metadata-json'),
+                    max_runs: parsePositiveInt(opts.maxRuns, '--max-runs'),
+                    expires_at: opts.expiresAt,
+                    client_context: parseJsonObject(opts.clientContextJson, '--client-context-json'),
+                }),
+            };
+            const result = await client.createExternalTrigger(orgId, data);
+            printJson(result);
+            printRefHint(result.id);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('get')
+        .description('Get an External Trigger by ID')
+        .argument('<triggerId>', 'External Trigger ID')
+        .action(async (triggerId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.getExternalTrigger(orgId, stripPrllScheme(triggerId));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('update')
+        .description('Update an External Trigger')
+        .argument('<triggerId>', 'External Trigger ID')
+        .option('--name <name>', 'Trigger name')
+        .option('--description <text>', 'Human-facing trigger description')
+        .option('--status <status>', 'active | paused')
+        .option('--target-ids <ids>', 'Comma-separated target agent user IDs')
+        .option('--attached-to-uri <uri>', 'Attach to a prll:// resource URI')
+        .option('--clear-attached-to', 'Explicitly clear attached_to_uri')
+        .option('--filter <expr>', 'CEL filter expression')
+        .option('--filter-metadata-json <json>', 'JSON object with UI/display metadata for the filter')
+        .option('--template <text>', 'Liquid template for the agent input body')
+        .option('--template-file <path>', 'Read the Liquid template from a file')
+        .option('--max-runs <n>', 'Maximum delivered runs before the trigger auto-archives')
+        .option('--clear-max-runs', 'Explicitly clear max_runs')
+        .option('--expires-at <ts>', 'Expiration time (RFC3339)')
+        .option('--clear-expires-at', 'Explicitly clear expires_at')
+        .option('--client-context-json <json>', 'JSON object stored with the trigger')
+        .action(async (triggerId, opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const conflicts = [
+                [opts.attachedToUri, opts.clearAttachedTo, '--attached-to-uri', '--clear-attached-to'],
+                [opts.maxRuns, opts.clearMaxRuns, '--max-runs', '--clear-max-runs'],
+                [opts.expiresAt, opts.clearExpiresAt, '--expires-at', '--clear-expires-at'],
+            ];
+            for (const [value, clear, valueFlag, clearFlag] of conflicts) {
+                if (value !== undefined && clear) {
+                    printError(new Error(`Do not pass ${valueFlag} together with ${clearFlag}.`));
+                    return;
+                }
+            }
+            const agentInputTemplate = await resolveTemplate(opts);
+            const patch = stripUndefined({
+                name: opts.name,
+                description: opts.description,
+                status: parseEnum(opts.status, triggerStatuses, '--status'),
+                target_agent_ids: opts.targetIds !== undefined ? parseIds(opts.targetIds, '--target-ids') : undefined,
+                attached_to_uri: opts.attachedToUri,
+                attached_to_uri_clear: opts.clearAttachedTo || undefined,
+                filter_expr: opts.filter,
+                filter_display_metadata: parseJsonObject(opts.filterMetadataJson, '--filter-metadata-json'),
+                agent_input_template: agentInputTemplate,
+                max_runs: parsePositiveInt(opts.maxRuns, '--max-runs'),
+                max_runs_clear: opts.clearMaxRuns || undefined,
+                expires_at: opts.expiresAt,
+                expires_at_clear: opts.clearExpiresAt || undefined,
+                client_context: parseJsonObject(opts.clientContextJson, '--client-context-json'),
+            });
+            if (Object.keys(patch).length === 0) {
+                printError(new Error('No fields to update. Provide at least one option.'));
+                return;
+            }
+            const result = await client.updateExternalTrigger(orgId, stripPrllScheme(triggerId), patch);
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('pause')
+        .description('Pause an External Trigger')
+        .argument('<triggerId>', 'External Trigger ID')
+        .action(async (triggerId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.updateExternalTrigger(orgId, stripPrllScheme(triggerId), {
+                status: 'paused',
+            });
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('resume')
+        .description('Resume a paused External Trigger')
+        .argument('<triggerId>', 'External Trigger ID')
+        .action(async (triggerId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.updateExternalTrigger(orgId, stripPrllScheme(triggerId), {
+                status: 'active',
+            });
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('delete')
+        .description('Archive an External Trigger')
+        .argument('<triggerId>', 'External Trigger ID')
+        .action(async (triggerId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            await client.deleteExternalTrigger(orgId, stripPrllScheme(triggerId));
+            printJson({ ok: true });
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('runs')
+        .description('List run history for an External Trigger')
+        .argument('<triggerId>', 'External Trigger ID')
+        .option('--limit <n>', 'Maximum number of runs to return', '50')
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .action(async (triggerId, opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.listExternalTriggerRuns(orgId, stripUndefined({
+                trigger_id: stripPrllScheme(triggerId),
+                limit: parsePositiveInt(opts.limit, '--limit'),
+                cursor: opts.cursor,
+            }));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('run')
+        .description('Get a single External Trigger run')
+        .argument('<runId>', 'External Trigger Run ID (xrn_...)')
+        .action(async (runId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.getExternalTriggerRun(orgId, stripPrllScheme(runId));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('events')
+        .description('List incoming events received by External Trigger Connections')
+        .option('--connection <connectionId>', 'Filter by External Trigger Connection ID')
+        .option('--limit <n>', 'Maximum number of events to return', '50')
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .action(async (opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.listExternalIngressEvents(orgId, stripUndefined({
+                connection_id: opts.connection ? stripPrllScheme(opts.connection) : undefined,
+                limit: parsePositiveInt(opts.limit, '--limit'),
+                cursor: opts.cursor,
+            }));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('event')
+        .description('Get a single incoming event by ID')
+        .argument('<eventId>', 'External Trigger Event ID (xin_...)')
+        .action(async (eventId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.getExternalIngressEvent(orgId, stripPrllScheme(eventId));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+}

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

@@ -1 +1 @@
-{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/commands/messages.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKzC,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,QAqJvD"}
+{"version":3,"file":"messages.d.ts","sourceRoot":"","sources":["../../src/commands/messages.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKzC,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,OAAO,QAwJvD"}

package/dist/commands/messages.js

@@ -11,6 +11,7 @@ export function registerMessageCommands(program) {
         .option('--limit <n>', 'Maximum number of messages to return', '20')
         .option('--before <cursor>', 'Cursor for messages before')
         .option('--after <cursor>', 'Cursor for messages after')
+        .option('--since <date>', 'Only messages at/after this time (RFC3339 or YYYY-MM-DD)')
         .option('--thread-root-id <id>', 'Filter by thread root message ID')
         .option('--top-level', 'Only return top-level messages')
         .action(async (chatId, opts) => {
@@ -21,6 +22,8 @@ export function registerMessageCommands(program) {
                 params.before = stripPrllScheme(opts.before);
             if (opts.after !== undefined)
                 params.after = stripPrllScheme(opts.after);
+            if (opts.since !== undefined)
+                params.since = opts.since;
             if (opts.threadRootId !== undefined)
                 params.thread_root_id = stripPrllScheme(opts.threadRootId);
             if (opts.topLevel)

package/dist/commands/refs.d.ts

@@ -1,3 +1,10 @@
 import { Command } from 'commander';
+/** Build the SDK ref-graph params from the positional URI + CLI flags. */
+export declare function buildRefGraphParams(uri: string, opts: {
+    depth?: string;
+}): {
+    uri: string;
+    depth?: number;
+};
 export declare function registerRefCommands(program: Command): void;
 //# sourceMappingURL=refs.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../../src/commands/refs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,QA+CnD"}
+{"version":3,"file":"refs.d.ts","sourceRoot":"","sources":["../../src/commands/refs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC,0EAA0E;AAC1E,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,MAAM,EACX,IAAI,EAAE;IAAE,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,GACvB;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAE,CAOjC;AAED,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,OAAO,QA+DnD"}

package/dist/commands/refs.js

@@ -1,5 +1,15 @@
 import { resolveCredentials } from '../lib/client.js';
-import { printJson, printError } from '../lib/output.js';
+import { ensurePrllScheme, parsePositiveInt, printError, printJson } from '../lib/output.js';
+/** Build the SDK ref-graph params from the positional URI + CLI flags. */
+export function buildRefGraphParams(uri, opts) {
+    const params = { uri: ensurePrllScheme(uri) };
+    // Drop a non-positive-integer --depth (NaN / 1.5 / -2) so the server applies
+    // its default; the server clamps the valid range (1–4) regardless.
+    const depth = parsePositiveInt(opts.depth);
+    if (depth !== undefined)
+        params.depth = depth;
+    return params;
+}
 export function registerRefCommands(program) {
     const refs = program.command('refs').description('Reference resolution and backlinks');
     refs
@@ -34,6 +44,20 @@ export function registerRefCommands(program) {
             printError(err);
         }
     });
+    refs
+        .command('graph <uri>')
+        .description('Multi-hop traversal of the prll:// reference graph around an entity-level URI (no path/anchor)')
+        .option('--depth <n>', 'Hops to traverse outward (server clamps to 1–4)', '2')
+        .action(async (uri, opts) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            const result = await client.getRefsGraph(orgId, buildRefGraphParams(uri, opts));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
     refs
         .command('check')
         .description('Check for broken references in the organization (admin only)')

package/dist/commands/search.d.ts

@@ -0,0 +1,20 @@
+import type { SearchParams } from '@parall/sdk';
+import { Command } from 'commander';
+/**
+ * Normalize a `--types m,t,w` flag into the server's CSV of canonical entity
+ * names (`message,task,wiki`). Unknown tokens pass through unchanged so the
+ * server can reject/ignore them. Returns undefined for an empty/absent flag so
+ * the server applies its default (search all three).
+ */
+export declare function normalizeSearchTypes(raw?: string): string | undefined;
+export interface SearchOpts {
+    types?: string;
+    channel?: string;
+    limit?: string;
+    wikiType?: string;
+    since?: string;
+}
+/** Build the SDK search params from the positional query + CLI flags. */
+export declare function buildSearchParams(query: string, opts: SearchOpts): SearchParams;
+export declare function registerSearchCommands(program: Command): void;
+//# sourceMappingURL=search.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../src/commands/search.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgBpC;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CASrE;AAED,MAAM,WAAW,UAAU;IACzB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,yEAAyE;AACzE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,YAAY,CAY/E;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,QA4BtD"}