@trydreamstate/cli 1.0.0

package/dist/commands/shared.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPackParser = buildPackParser;
+exports.packScaffold = packScaffold;
+exports.runPackInit = runPackInit;
+exports.runPackCommand = runPackCommand;
+exports.renderPackUsage = renderPackUsage;
+const node_util_1 = require("node:util");
+// CanonicalApiCapabilityId comes from ../index on purpose. Do not reach into the
+// shared types package's built dist for it: those built id unions have no source on
+// main and no generator, so they still carry pre-cutover spellings, and
+// audit:canonical-cutover:clean treats importing them as a release blocker.
+const index_1 = require("../index");
+const node_fs_1 = require("node:fs");
+const MODES = ['dry_run', 'live', 'smoke_test'];
+function parseObject(raw, flag) {
+    try {
+        const value = JSON.parse(raw);
+        if (!value || typeof value !== 'object' || Array.isArray(value))
+            throw new Error('must contain a JSON object');
+        return value;
+    }
+    catch (error) {
+        throw new index_1.CliUsageError(`${flag} ${error instanceof Error ? error.message : 'is invalid JSON'}`);
+    }
+}
+function parseJson(raw, flag) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        throw new index_1.CliUsageError(`${flag} must contain valid JSON`);
+    }
+}
+function parseMode(value) {
+    if (value === undefined)
+        return undefined;
+    if (MODES.includes(value))
+        return value;
+    throw new index_1.CliUsageError(`--mode must be one of: ${MODES.join(', ')}`);
+}
+function buildPackParser(pack, kind, specs, usage) {
+    return (argv) => {
+        const spec = specs.find((candidate) => candidate.verb === argv[0]);
+        if (!spec)
+            throw new index_1.CliUsageError(`Unknown ${pack} verb: ${argv[0] ?? '(missing)'}\n${usage}`);
+        const options = {
+            mode: { type: 'string' }, 'dry-run': { type: 'boolean' }, live: { type: 'boolean' }, 'agent-session-id': { type: 'string' },
+            'idempotency-key': { type: 'string' }, 'max-credits': { type: 'string' }, params: { type: 'string' },
+            'json-output': { type: 'boolean' }, open: { type: 'boolean' }, help: { type: 'boolean', short: 'h' },
+        };
+        // A verb that takes a JSON document on a flag also takes it from a file, so a
+        // whole authored document can be linted or imported straight off disk instead of
+        // being pasted through the shell. The competitor authors this way and it is the
+        // only thing their file workflow had that ours did not.
+        // A verb that declares its own `file` flag owns the name, for example init, whose
+        // --file is where the scaffold is written rather than a document to read.
+        const declaresOwnFile = Object.keys(spec.flags ?? {}).includes('file');
+        const jsonFlag = declaresOwnFile
+            ? undefined
+            : Object.entries(spec.flags ?? {}).find(([, definition]) => definition.document === true);
+        if (!declaresOwnFile)
+            options.file = { type: 'string' };
+        for (const [flag, definition] of Object.entries(spec.flags ?? {}))
+            options[flag] = { type: definition.type };
+        const { values, positionals } = (0, node_util_1.parseArgs)({ args: argv.slice(1), options, allowPositionals: true, strict: true });
+        const mode = values.mode;
+        const dryRun = values['dry-run'];
+        const live = values.live;
+        const agentSessionId = values['agent-session-id'];
+        const idempotencyKey = values['idempotency-key'];
+        const rawParams = values.params;
+        const rawMaxCredits = values['max-credits'];
+        if (values.help)
+            throw new index_1.CliUsageError(usage);
+        const positional = spec.positional ?? [];
+        // A document supplied inline or from a file is authored, not saved, so there is no
+        // id to name yet. lint and its kin accept a hypothetical document, which is the
+        // whole point of authoring in a file before anything exists in the workspace.
+        const documentSupplied = values.file !== undefined
+            || (jsonFlag !== undefined && values[jsonFlag[0]] !== undefined);
+        const requiredPositionals = positional.filter((definition) => definition.optional !== true).length;
+        const positionalsAcceptable = positionals.length <= positional.length
+            && (positionals.length >= requiredPositionals || (documentSupplied && positionals.length === 0));
+        if (!positionalsAcceptable)
+            throw new index_1.CliUsageError(`Usage: ${usage}`);
+        if ((mode && (dryRun || live)) || (dryRun && live)) {
+            throw new index_1.CliUsageError('Use exactly one of --mode, --dry-run, or --live.');
+        }
+        const input = rawParams ? parseObject(rawParams, '--params') : {};
+        positional.forEach((definition, index) => {
+            const value = positionals[index];
+            if (value !== undefined)
+                input[definition.into] = value;
+        });
+        for (const [flag, definition] of Object.entries(spec.flags ?? {})) {
+            const value = values[flag];
+            if (value === undefined)
+                continue;
+            if (definition.json) {
+                input[definition.into] = parseJson(String(value), `--${flag}`);
+            }
+            else if (definition.number) {
+                const parsedNumber = Number(String(value));
+                if (!Number.isFinite(parsedNumber))
+                    throw new index_1.CliUsageError(`--${flag} must be a number`);
+                input[definition.into] = parsedNumber;
+            }
+            else {
+                input[definition.into] = value;
+            }
+        }
+        const filePath = declaresOwnFile ? undefined : values.file;
+        if (filePath !== undefined) {
+            if (jsonFlag && values[jsonFlag[0]] !== undefined) {
+                throw new index_1.CliUsageError(`Use either --${jsonFlag[0]} or --file, not both.`);
+            }
+            let contents;
+            try {
+                contents = (0, node_fs_1.readFileSync)(filePath, 'utf8');
+            }
+            catch (error) {
+                throw new index_1.CliUsageError(`--file could not be read: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const parsed = parseJson(contents, `--file ${filePath}`);
+            if (jsonFlag) {
+                input[jsonFlag[1].into] = parsed;
+            }
+            else if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+                // A verb with no single document flag spreads the file's fields across its
+                // params, which is what `dreamstate <pack> init` writes and what `create`
+                // needs: name and steps are separate params there, not one document. Without
+                // this, the scaffold composed with no verb at all.
+                Object.assign(input, parsed);
+            }
+            else {
+                throw new index_1.CliUsageError(`--file for ${pack} ${spec.verb} must contain a JSON object of params.`);
+            }
+        }
+        // kind is the discriminator of the SHARED authoring family only. The
+        // family-specific capabilities have strict schemas that do not declare it,
+        // so injecting it everywhere made every one of those verbs fail validation
+        // with an unrecognized key before it reached the server's real work.
+        if (spec.capabilityId.startsWith('workflow.automations.'))
+            input.kind = kind;
+        const explicitMode = dryRun ? 'dry_run' : live ? 'live' : parseMode(mode);
+        const maxCredits = rawMaxCredits === undefined ? undefined : Number(rawMaxCredits);
+        if (maxCredits !== undefined && (!Number.isFinite(maxCredits) || maxCredits < 0))
+            throw new index_1.CliUsageError('--max-credits must be a non-negative number');
+        return {
+            command: 'pack', pack, verb: spec.verb, capabilityId: spec.capabilityId, input,
+            ...(explicitMode ? { mode: explicitMode } : spec.mutating ? { mode: 'dry_run' } : {}),
+            ...(agentSessionId ? { agentSessionId } : {}),
+            ...(idempotencyKey ? { idempotencyKey } : {}),
+            ...(maxCredits === undefined ? {} : { maxCredits }), ...(values['json-output'] ? { jsonOutput: true } : {}),
+            ...(values.open ? { open: true } : {}),
+        };
+    };
+}
+/**
+ * A starter document written to disk, so authoring can begin from a file the way the
+ * rest of this pack now accepts one. It writes nothing to the workspace and calls no
+ * API: the point is to hand back something `lint --file` will accept and refuse
+ * usefully, rather than to guess a valid sequence on the caller's behalf.
+ */
+function packScaffold(kind, name) {
+    // The step fields are FLAT and the step carries an id. An earlier scaffold nested
+    // channel/action under `fields` and omitted the id, and the document it wrote was
+    // refused by our own lint with `node_contract_unresolved: Node unknown has no
+    // canonical node-contract mapping`, because canonicalSequenceStepContractNode reads
+    // step.kind and step.action off the step itself. A scaffold whose output the next
+    // command in its own printed next_steps rejects is worse than no scaffold.
+    return kind === 'sequence'
+        ? {
+            kind: 'sequence',
+            name,
+            steps: [
+                {
+                    id: 'step_1',
+                    kind: 'linkedin',
+                    channel: 'linkedin',
+                    // send_dm, not send_connection_request. compose refuses the latter on purpose:
+                    // a send_dm carrying note_template sends the invitation and then body_template
+                    // once it is accepted, so one step covers both. A scaffold naming the refused
+                    // step lints clean and then fails at create, which is the same trap as before.
+                    action: 'send_dm',
+                    note_template: 'Hi {{first_name}}, would love to connect.',
+                    body_template: 'Thanks for connecting, {{first_name}}.',
+                },
+            ],
+        }
+        : { kind: 'workflow', name, nodes: [], edges: [] };
+}
+function runPackInit(kind, command, stdout) {
+    if (command.command !== 'pack')
+        throw new index_1.CliUsageError('Pack command required.');
+    const input = command.input;
+    const name = typeof input.name === 'string' && input.name.trim() ? input.name.trim() : `My ${kind}`;
+    const target = typeof input.file === 'string' && input.file.trim()
+        ? input.file.trim()
+        : `./${kind}.json`;
+    if ((0, node_fs_1.existsSync)(target)) {
+        throw new index_1.CliUsageError(`${target} already exists. Pass --file <path> to write somewhere else.`);
+    }
+    const document = packScaffold(kind, name);
+    (0, node_fs_1.writeFileSync)(target, `${JSON.stringify(document, null, 2)}\n`, 'utf8');
+    stdout.write(`${JSON.stringify({
+        ok: true,
+        data: {
+            file: target,
+            kind,
+            next_steps: [
+                `dreamstate ${kind}s lint --file ${target} --json-output`,
+                `dreamstate ${kind}s import --file ${target} --json-output`,
+            ],
+        },
+    }, null, command.jsonOutput ? 0 : 2)}\n`);
+}
+async function runPackCommand(client, command, stdout) {
+    if (command.command !== 'pack')
+        throw new index_1.CliUsageError('Pack command required.');
+    // Every run needs a tool_turn_token from tools_get, exactly as the generic
+    // tools run path does. Without it the server refuses capability_not_fetched,
+    // which made every pack verb unusable even though its capability id was right.
+    const { toolTurnToken } = require('../index');
+    const turnToken = toolTurnToken(await client.getTool(command.capabilityId));
+    const result = await client.runCapability(command.capabilityId, {
+        params: command.input, tool_turn_token: turnToken, ...(command.mode ? { mode: command.mode } : {}),
+        ...(command.agentSessionId ? { agent_session_id: command.agentSessionId } : {}),
+        ...(command.maxCredits === undefined ? {} : { max_credits: command.maxCredits }),
+    }, command.idempotencyKey);
+    stdout.write(`${JSON.stringify(result, null, command.jsonOutput ? 0 : 2)}\n`);
+    if (command.open) {
+        const root = result && typeof result === 'object' ? result : {};
+        const webUrl = root.meta?.web_url ?? root.data?.web_url;
+        if (typeof webUrl !== 'string')
+            throw new index_1.CliUsageError('The API response did not include a web_url.');
+        (0, index_1.openWebUrl)(webUrl);
+    }
+}
+function renderPackUsage(pack, specs) {
+    return `Usage: dreamstate ${pack} <verb> [args] [flags]\n\nVerbs:\n${specs.map((spec) => `  ${spec.verb.padEnd(18)} ${spec.summary}`).join('\n')}`;
+}

package/dist/commands/workflows.d.ts

@@ -0,0 +1,7 @@
+import { runPackCommand, type PackVerbSpec } from './shared';
+import type { CliCommand } from '../index';
+export declare const WORKFLOW_VERBS: PackVerbSpec[];
+export declare const WORKFLOWS_USAGE: string;
+export declare const parseWorkflowsCommand: (argv: string[]) => CliCommand;
+export declare function runWorkflowsCommand(client: Parameters<typeof runPackCommand>[0], command: CliCommand, stdout: NodeJS.WritableStream): Promise<void>;
+//# sourceMappingURL=workflows.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"workflows.d.ts","sourceRoot":"","sources":["../../src/commands/workflows.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,cAAc,EAEd,KAAK,YAAY,EAClB,MAAM,UAAU,CAAC;AAClB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAS3C,eAAO,MAAM,cAAc,EAAE,YAAY,EA8BxC,CAAC;AAEF,eAAO,MAAM,eAAe,EAAE,MAAqD,CAAC;AACpF,eAAO,MAAM,qBAAqB,gCAA4E,CAAC;AAC/G,wBAAsB,mBAAmB,CACvC,MAAM,EAAE,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC,CAAC,CAAC,EAC5C,OAAO,EAAE,UAAU,EACnB,MAAM,EAAE,MAAM,CAAC,cAAc,GAC5B,OAAO,CAAC,IAAI,CAAC,CAMf"}

package/dist/commands/workflows.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWorkflowsCommand = exports.WORKFLOWS_USAGE = exports.WORKFLOW_VERBS = void 0;
+exports.runWorkflowsCommand = runWorkflowsCommand;
+const shared_1 = require("./shared");
+const id = [{ name: 'id', into: 'automation_id' }];
+const workflowId = [{ name: 'id', into: 'workflow_id' }];
+const campaignId = [{ name: 'id', into: 'campaign_id' }];
+const workflowVersion = {
+    'expected-latest-draft-version-id': { type: 'string', into: 'expected_latest_draft_version_id' },
+};
+exports.WORKFLOW_VERBS = [
+    { verb: 'list', capabilityId: 'workflow.automations.list', summary: 'List workflows.', flags: { limit: { type: 'string', into: 'limit' }, cursor: { type: 'string', into: 'cursor' }, lifecycle: { type: 'string', into: 'lifecycle' }, 'include-archived': { type: 'boolean', into: 'include_archived' }, search: { type: 'string', into: 'search' } }, mutating: false },
+    // Local only: writes a starter document to disk and calls no API, so authoring can
+    // begin from a file. capabilityId names the verb this scaffold is meant to feed.
+    { verb: 'init', capabilityId: 'workflow.automations.lint', summary: 'Write a starter workflow document to a local file. Calls no API and changes nothing.', flags: { name: { type: 'string', into: 'name' }, file: { type: 'string', into: 'file' } }, mutating: false },
+    { verb: 'get', capabilityId: 'workflow.automations.get', summary: 'Get workflow.', positional: id, mutating: false },
+    { verb: 'create', capabilityId: 'workflow.automations.compose', summary: 'Create workflow.', flags: { name: { type: 'string', into: 'name' }, description: { type: 'string', into: 'description' }, trigger: { type: 'string', into: 'trigger', json: true }, steps: { type: 'string', into: 'steps', json: true } }, mutating: true },
+    { verb: 'update', capabilityId: 'workflow.automations.update', summary: 'Update workflow.', positional: id, flags: { ...workflowVersion, patch: { type: 'string', into: 'patch', json: true, document: true } }, mutating: true },
+    { verb: 'lint', capabilityId: 'workflow.automations.lint', summary: 'Lint workflow.', positional: id, flags: { phase: { type: 'string', into: 'phase' }, document: { type: 'string', into: 'document', json: true, document: true } }, mutating: false },
+    { verb: 'preview', capabilityId: 'workflow.automations.preview', summary: 'Preview workflow effects.', positional: id, mutating: false },
+    { verb: 'variables', capabilityId: 'workflow.automations.variables_list', summary: 'List workflow variables.', positional: id, flags: { 'node-id': { type: 'string', into: 'node_id' }, query: { type: 'string', into: 'query' }, limit: { type: 'string', into: 'limit' }, document: { type: 'string', into: 'document', json: true, document: true } }, mutating: false },
+    { verb: 'node-catalog', capabilityId: 'workflow.automations.node_catalog', summary: 'List workflow node types.', flags: { 'node-kind': { type: 'string', into: 'node_kind' }, query: { type: 'string', into: 'query' }, family: { type: 'string', into: 'family' }, 'include-blocked': { type: 'boolean', into: 'include_blocked' } }, mutating: false },
+    { verb: 'node-inspect', capabilityId: 'workflow.automations.node_inspect', summary: 'Inspect workflow node type.', flags: { 'node-kind': { type: 'string', into: 'node_kind' }, subtype: { type: 'string', into: 'subtype' }, config: { type: 'string', into: 'config', json: true }, 'automation-id': { type: 'string', into: 'automation_id' }, 'node-id': { type: 'string', into: 'node_id' } }, mutating: false },
+    { verb: 'node-add', capabilityId: 'workflow.automations.node_add', summary: 'Add workflow node.', positional: id, flags: { ...workflowVersion, 'after-node-id': { type: 'string', into: 'after_node_id' }, branch: { type: 'string', into: 'branch' }, node: { type: 'string', into: 'node', json: true, document: true } }, mutating: true },
+    { verb: 'node-patch', capabilityId: 'workflow.automations.node_patch', summary: 'Patch workflow node.', positional: id, flags: { ...workflowVersion, 'node-id': { type: 'string', into: 'node_id' }, fields: { type: 'string', into: 'fields', json: true } }, mutating: true },
+    { verb: 'node-remove', capabilityId: 'workflow.automations.node_remove', summary: 'Remove workflow node.', positional: id, flags: { ...workflowVersion, 'node-id': { type: 'string', into: 'node_id' } }, mutating: true },
+    { verb: 'node-move', capabilityId: 'workflow.automations.node_move', summary: 'Move workflow node.', positional: id, flags: { ...workflowVersion, 'node-id': { type: 'string', into: 'node_id' }, 'after-node-id': { type: 'string', into: 'after_node_id' }, branch: { type: 'string', into: 'branch' } }, mutating: true },
+    { verb: 'field-options', capabilityId: 'workflow.automations.field_options', summary: 'Resolve workflow node field options.', flags: { 'node-kind': { type: 'string', into: 'node_kind' }, subtype: { type: 'string', into: 'subtype' }, 'automation-id': { type: 'string', into: 'automation_id' }, 'node-id': { type: 'string', into: 'node_id' }, 'field-key': { type: 'string', into: 'field_key' }, 'field-keys': { type: 'string', into: 'field_keys', json: true }, query: { type: 'string', into: 'query' }, limit: { type: 'string', into: 'limit' }, cursor: { type: 'string', into: 'cursor' }, 'field-context': { type: 'string', into: 'field_context', json: true } }, mutating: false },
+    { verb: 'draft-save', capabilityId: 'workflow.workflows.draft_save', summary: 'Save workflow draft.', positional: id, flags: { graph: { type: 'string', into: 'graph', json: true, document: true }, 'expected-latest-draft-version-id': { type: 'string', into: 'expected_latest_draft_version_id' } }, mutating: true },
+    { verb: 'publish', capabilityId: 'workflow.workflows.draft_publish', summary: 'Publish workflow draft.', positional: id, flags: { 'expected-draft-version-id': { type: 'string', into: 'expected_draft_version_id' }, 'expected-active-version-id': { type: 'string', into: 'expected_active_version_id' } }, mutating: true },
+    { verb: 'activate', capabilityId: 'workflow.workflows.activate', summary: 'Activate workflow.', positional: id, flags: { 'expected-version-id': { type: 'string', into: 'expected_version_id' }, 'delivery-binding': { type: 'string', into: 'delivery_binding', json: true } }, mutating: true },
+    { verb: 'deactivate', capabilityId: 'workflow.workflows.deactivate', summary: 'Deactivate workflow.', positional: id, mutating: true },
+    { verb: 'enroll', capabilityId: 'workflow.workflows.enroll_selection', summary: 'Enroll selection in workflow.', positional: id, flags: { selection: { type: 'string', into: 'selection', json: true } }, mutating: true },
+    { verb: 'runs', capabilityId: 'workflow.workflows.runs_list', summary: 'List workflow runs.', positional: workflowId, flags: { workflow: { type: 'string', into: 'workflow_id' }, limit: { type: 'string', into: 'limit' } }, mutating: false },
+    { verb: 'run', capabilityId: 'workflow.workflows.run_trace_get', summary: 'Get workflow run trace.', positional: id, flags: { 'subject-id': { type: 'string', into: 'subject_id' } }, mutating: false },
+    { verb: 'retry', capabilityId: 'workflow.workflows.run_retry', summary: 'Retry failed workflow run event.', positional: id, flags: { 'subject-id': { type: 'string', into: 'subject_id' }, 'failed-event-id': { type: 'string', into: 'failed_event_id' }, 'failed-node-id': { type: 'string', into: 'failed_node_id' } }, mutating: true },
+    { verb: 'duplicate', capabilityId: 'workflow.automations.duplicate', summary: 'Duplicate workflow.', positional: id, flags: { ...workflowVersion, name: { type: 'string', into: 'name' } }, mutating: true },
+    { verb: 'archive', capabilityId: 'workflow.automations.archive', summary: 'Archive workflow.', positional: id, flags: { ...workflowVersion, reason: { type: 'string', into: 'reason' } }, mutating: true },
+    { verb: 'export', capabilityId: 'workflow.automations.export', summary: 'Export workflow.', positional: id, mutating: false },
+    { verb: 'import', capabilityId: 'workflow.automations.import', summary: 'Import workflow.', flags: { name: { type: 'string', into: 'name' }, document: { type: 'string', into: 'document', json: true, document: true } }, mutating: true },
+];
+exports.WORKFLOWS_USAGE = (0, shared_1.renderPackUsage)('workflows', exports.WORKFLOW_VERBS);
+exports.parseWorkflowsCommand = (0, shared_1.buildPackParser)('workflows', 'workflow', exports.WORKFLOW_VERBS, exports.WORKFLOWS_USAGE);
+async function runWorkflowsCommand(client, command, stdout) {
+    if (command.command === 'pack' && command.verb === 'init') {
+        (0, shared_1.runPackInit)('workflow', command, stdout);
+        return;
+    }
+    await (0, shared_1.runPackCommand)(client, command, stdout);
+}

package/dist/config.d.ts

@@ -0,0 +1,25 @@
+export declare class MissingApiUrlError extends Error {
+    readonly code = "missing_api_url";
+    constructor(message?: string);
+}
+export declare class ApiBaseUrlError extends Error {
+    readonly code = "invalid_api_url";
+    constructor(message: string);
+}
+export declare class HostPinMismatchError extends Error {
+    readonly code = "host_pin_mismatch";
+    constructor(message: string);
+}
+export declare class MissingApiKeyError extends Error {
+    readonly code = "not_authenticated";
+    constructor(message?: string);
+}
+export declare class ApiKeyFileError extends Error {
+    constructor(message: string);
+}
+export declare function credentialsPath(homeDirectory?: string, environment?: NodeJS.ProcessEnv): string;
+export declare function resolveApiBaseUrl(environment?: NodeJS.ProcessEnv): string;
+export declare function resolveApiKey(environment?: NodeJS.ProcessEnv, path?: string): Promise<string>;
+export declare function readApiKeyFile(path: string): Promise<string>;
+export declare function storeApiKey(apiKey: string, path?: string): Promise<string>;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAIA,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,qBAAqB;gBAEtB,OAAO,SAA8C;CAIlE;AAED,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,qBAAqB;gBAEtB,OAAO,EAAE,MAAM;CAI5B;AAED,qBAAa,oBAAqB,SAAQ,KAAK;IAC7C,QAAQ,CAAC,IAAI,uBAAuB;gBACxB,OAAO,EAAE,MAAM;CAC5B;AAED,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,uBAAuB;gBAGlC,OAAO,SAA6E;CAKvF;AAED,qBAAa,eAAgB,SAAQ,KAAK;gBAC5B,OAAO,EAAE,MAAM;CAI5B;AAED,wBAAgB,eAAe,CAC7B,aAAa,SAAY,EACzB,WAAW,GAAE,MAAM,CAAC,UAAwB,GAC3C,MAAM,CAGR;AAED,wBAAgB,iBAAiB,CAAC,WAAW,GAAE,MAAM,CAAC,UAAwB,GAAG,MAAM,CA+BtF;AAWD,wBAAsB,aAAa,CACjC,WAAW,GAAE,MAAM,CAAC,UAAwB,EAC5C,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,MAAM,CAAC,CAajB;AAED,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAiBlE;AAED,wBAAsB,WAAW,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,SAAoB,GAAG,OAAO,CAAC,MAAM,CAAC,CAW3F"}

package/dist/config.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ApiKeyFileError = exports.MissingApiKeyError = exports.HostPinMismatchError = exports.ApiBaseUrlError = exports.MissingApiUrlError = void 0;
+exports.credentialsPath = credentialsPath;
+exports.resolveApiBaseUrl = resolveApiBaseUrl;
+exports.resolveApiKey = resolveApiKey;
+exports.readApiKeyFile = readApiKeyFile;
+exports.storeApiKey = storeApiKey;
+const promises_1 = require("node:fs/promises");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+class MissingApiUrlError extends Error {
+    code = 'missing_api_url';
+    constructor(message = 'No API URL found. Set DREAMSTATE_API_URL.') {
+        super(message);
+        this.name = 'MissingApiUrlError';
+    }
+}
+exports.MissingApiUrlError = MissingApiUrlError;
+class ApiBaseUrlError extends Error {
+    code = 'invalid_api_url';
+    constructor(message) {
+        super(message);
+        this.name = 'ApiBaseUrlError';
+    }
+}
+exports.ApiBaseUrlError = ApiBaseUrlError;
+class HostPinMismatchError extends Error {
+    code = 'host_pin_mismatch';
+    constructor(message) { super(message); this.name = 'HostPinMismatchError'; }
+}
+exports.HostPinMismatchError = HostPinMismatchError;
+class MissingApiKeyError extends Error {
+    code = 'not_authenticated';
+    constructor(message = 'No API key found. Run `dreamstate auth login` or set DREAMSTATE_API_KEY.') {
+        super(message);
+        this.name = 'MissingApiKeyError';
+    }
+}
+exports.MissingApiKeyError = MissingApiKeyError;
+class ApiKeyFileError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ApiKeyFileError';
+    }
+}
+exports.ApiKeyFileError = ApiKeyFileError;
+function credentialsPath(homeDirectory = (0, node_os_1.homedir)(), environment = process.env) {
+    const configuredDirectory = environment.DREAMSTATE_CONFIG_DIR?.trim();
+    return (0, node_path_1.join)(configuredDirectory || (0, node_path_1.join)(homeDirectory, '.dreamstate'), 'credentials');
+}
+function resolveApiBaseUrl(environment = process.env) {
+    const candidate = environment.DREAMSTATE_API_URL?.trim() || 'https://api.trydreamstate.com/api/v1';
+    let url;
+    try {
+        url = new URL(candidate);
+    }
+    catch {
+        throw new ApiBaseUrlError('DREAMSTATE_API_URL must be an absolute HTTPS URL, or explicit loopback HTTP URL.');
+    }
+    if (url.username || url.password) {
+        throw new ApiBaseUrlError('DREAMSTATE_API_URL must not contain credentials.');
+    }
+    if (url.protocol !== 'https:' && url.protocol !== 'http:') {
+        throw new ApiBaseUrlError('DREAMSTATE_API_URL must use HTTPS, or HTTP on explicit loopback only.');
+    }
+    if (url.protocol === 'http:' && !isExplicitLoopbackHttpOrigin(candidate, url)) {
+        throw new ApiBaseUrlError('DREAMSTATE_API_URL may use HTTP only for localhost, 127.0.0.1, or [::1].');
+    }
+    const pathSegments = url.pathname.split('/').filter(Boolean);
+    if (!pathSegments.some((segment, index) => segment === 'api' && pathSegments[index + 1] === 'v1')) {
+        url.pathname = `${url.pathname.replace(/\/+$/, '')}/api/v1`;
+    }
+    const resolved = url.toString().replace(/\/+$/, '');
+    const required = environment.DREAMSTATE_REQUIRE_API_URL?.trim();
+    if (required) {
+        let requiredUrl;
+        try {
+            requiredUrl = new URL(required);
+        }
+        catch {
+            throw new HostPinMismatchError('DREAMSTATE_REQUIRE_API_URL must be an absolute URL.');
+        }
+        if (url.origin !== requiredUrl.origin) {
+            throw new HostPinMismatchError(`API host pin mismatch: configured ${url.origin}, required ${requiredUrl.origin}.`);
+        }
+    }
+    return resolved;
+}
+function isExplicitLoopbackHttpOrigin(candidate, url) {
+    const authority = candidate.match(/^http:\/\/([^/?#]*)/i)?.[1];
+    if (!authority || authority !== url.host)
+        return false;
+    return authority === 'localhost' || authority === '127.0.0.1' || authority === '[::1]'
+        || /^localhost:\d+$/.test(authority)
+        || /^127\.0\.0\.1:\d+$/.test(authority)
+        || /^\[::1\]:\d+$/.test(authority);
+}
+async function resolveApiKey(environment = process.env, path) {
+    const environmentKey = environment.DREAMSTATE_API_KEY?.trim();
+    if (environmentKey)
+        return environmentKey;
+    const credentialFilePath = path ?? credentialsPath(undefined, environment);
+    try {
+        const storedKey = (await (0, promises_1.readFile)(credentialFilePath, 'utf8')).trim();
+        if (storedKey)
+            return storedKey;
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+    throw new MissingApiKeyError();
+}
+async function readApiKeyFile(path) {
+    let file;
+    try {
+        file = await (0, promises_1.stat)(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new ApiKeyFileError(`--api-key-file not found: ${path}`);
+        }
+        throw error;
+    }
+    if (!file.isFile()) {
+        throw new ApiKeyFileError(`--api-key-file must point to a regular file: ${path}`);
+    }
+    if (process.platform !== 'win32' && (file.mode & 0o777) !== 0o600) {
+        throw new ApiKeyFileError(`--api-key-file must be mode 0600: ${path}`);
+    }
+    return (await (0, promises_1.readFile)(path, 'utf8')).trim();
+}
+async function storeApiKey(apiKey, path = credentialsPath()) {
+    const normalized = apiKey.trim();
+    if (!normalized.startsWith('ds_live_')) {
+        throw new Error('Dreamstate API keys must start with ds_live_.');
+    }
+    const directory = (0, node_path_1.join)(path, '..');
+    await (0, promises_1.mkdir)(directory, { recursive: true, mode: 0o700 });
+    await (0, promises_1.writeFile)(path, `${normalized}\n`, { encoding: 'utf8', mode: 0o600 });
+    await (0, promises_1.chmod)(path, 0o600);
+    return path;
+}

package/dist/index.d.ts

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+import { type ChildProcess } from 'node:child_process';
+import { type SkillInstallAgent } from './skillInstaller';
+export type CanonicalApiCapabilityId = string;
+export declare const CLI_EXIT: {
+    readonly SUCCESS: 0;
+    readonly UNCLASSIFIED: 1;
+    readonly USAGE: 2;
+    readonly AUTH: 3;
+    readonly NOT_FOUND: 4;
+    readonly SERVER: 5;
+    readonly RATE_LIMITED: 6;
+    readonly APPROVAL: 7;
+    readonly TIMEOUT: 8;
+    readonly REFUSED: 9;
+    readonly TRANSPORT: 10;
+};
+export type CliCommand = {
+    command: 'help';
+} | {
+    command: 'version';
+} | {
+    command: 'login';
+    apiKeyFile?: string;
+    token?: string;
+    jsonOutput?: boolean;
+} | {
+    command: 'logout';
+    jsonOutput?: boolean;
+} | {
+    command: 'whoami';
+    jsonOutput?: boolean;
+} | {
+    command: 'packs_list';
+    jsonOutput?: boolean;
+} | {
+    command: 'packs_get';
+    packId: string;
+    jsonOutput?: boolean;
+} | {
+    command: 'packs_route';
+    goal: string;
+    jsonOutput?: boolean;
+} | {
+    command: 'skills_list';
+    query: Record<string, unknown>;
+    jsonOutput?: boolean;
+} | {
+    command: 'skills_get';
+    skillId: string;
+    jsonOutput?: boolean;
+} | {
+    command: 'skills_search';
+    query: Record<string, unknown>;
+    jsonOutput?: boolean;
+} | {
+    command: 'skills_install';
+    skillId: string;
+    agents: SkillInstallAgent[];
+    project?: boolean;
+    copy?: boolean;
+    jsonOutput?: boolean;
+} | {
+    command: 'skills_doctor';
+    agents: SkillInstallAgent[];
+    project?: boolean;
+    jsonOutput?: boolean;
+} | {
+    command: 'commands_search';
+    term: string;
+    jsonOutput?: boolean;
+} | {
+    command: 'tools_search';
+    query: Record<string, unknown>;
+    jsonOutput?: boolean;
+} | {
+    command: 'tools_get';
+    capabilityId: string;
+    jsonOutput?: boolean;
+} | {
+    command: 'tools_run';
+    capabilityId: string;
+    body: Record<string, unknown>;
+    turnToken?: string;
+    idempotencyKey?: string;
+    open?: boolean;
+    jsonOutput?: boolean;
+} | {
+    command: 'pack';
+    pack: 'sequences' | 'workflows';
+    verb: string;
+    capabilityId: CanonicalApiCapabilityId;
+    input: Record<string, unknown>;
+    pathParams?: Record<string, string>;
+    mode?: 'dry_run' | 'live' | 'smoke_test';
+    agentSessionId?: string;
+    idempotencyKey?: string;
+    jsonOutput?: boolean;
+    open?: boolean;
+    maxCredits?: number;
+} | {
+    command: 'tables_import';
+    tableId: string;
+    file: string;
+    format?: 'csv' | 'json' | 'jsonl' | 'xlsx';
+    preview?: boolean;
+    upsertKey?: string;
+    background: boolean;
+    jsonOutput?: boolean;
+} | {
+    command: 'runs_list';
+    query: Record<string, unknown>;
+    jsonOutput?: boolean;
+} | {
+    command: 'runs_get';
+    runId: string;
+    jsonOutput?: boolean;
+} | {
+    command: 'runs_resume';
+    runId: string;
+    stateVersion: number;
+    reason?: string;
+    idempotencyKey?: string;
+    open?: boolean;
+    jsonOutput?: boolean;
+} | {
+    command: 'runs_events';
+    runId: string;
+    jsonOutput?: boolean;
+} | {
+    command: 'runs_cancel';
+    runId: string;
+    body: Record<string, unknown>;
+    idempotencyKey?: string;
+    jsonOutput?: boolean;
+};
+export interface CliRuntime {
+    stdin?: NodeJS.ReadableStream & {
+        isTTY?: boolean;
+    };
+    stdout?: NodeJS.WritableStream;
+    env?: NodeJS.ProcessEnv;
+    promptHidden?: (prompt: string) => Promise<string>;
+    credentialsPath?: string;
+    requestTimeoutMs?: number;
+    openWebUrl?: (url: string) => void;
+    stderr?: NodeJS.WritableStream;
+    deviceState?: string;
+    sleep?: (milliseconds: number) => Promise<void>;
+    homeDirectory?: string;
+}
+export declare class CliUsageError extends Error {
+    constructor(message: string);
+}
+export declare function parseCliArgs(argv: string[]): CliCommand;
+export declare function toolTurnToken(value: unknown): string;
+export declare function refusalEnvelope(error: unknown, exitCode: number): Record<string, unknown>;
+type SpawnLike = (command: string, args: readonly string[], options: {
+    detached: boolean;
+    stdio: 'ignore';
+    shell: false;
+}) => Pick<ChildProcess, 'unref'>;
+export declare function openWebUrl(rawUrl: string, launch?: SpawnLike): void;
+export declare function exitCodeForError(error: unknown): number;
+export declare function runCli(argv?: string[], runtime?: CliRuntime): Promise<void>;
+export {};
+//# sourceMappingURL=index.d.ts.map