@skrr-ai/cli 0.1.8

package/dist/commands/workspaces/list.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const format_1 = require("../../lib/format");
+const config_1 = require("../../lib/config");
+const workspaces_1 = require("../../lib/workspaces");
+class WorkspacesList extends base_command_1.BaseCommand {
+    static description = 'List the workspaces you belong to, marking the one in use';
+    static examples = [
+        '<%= config.bin %> workspaces list',
+        '<%= config.bin %> workspaces list --json',
+    ];
+    static flags = {
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { flags } = await this.parse(WorkspacesList);
+        let listing;
+        try {
+            listing = await (0, workspaces_1.listWorkspaceListing)();
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        const rows = listing.rows;
+        const current = (0, config_1.selectedWorkspaceId)();
+        if (flags.json) {
+            this.log(JSON.stringify({
+                selected: current ?? null,
+                workspaces: rows.map((r) => ({ ...r, inUse: r.id === current })),
+            }, null, 2));
+            return;
+        }
+        if (rows.length === 0) {
+            this.log('You do not belong to any workspace yet.');
+            return;
+        }
+        (0, format_1.renderTable)(rows.map((row) => ({
+            inUse: row.id === current ? '*' : '',
+            id: row.id,
+            name: row.name ?? '',
+            role: row.role ?? '',
+        })), [
+            { key: 'inUse', header: '' },
+            { key: 'id', header: 'ID' },
+            { key: 'name', header: 'NAME' },
+            { key: 'role', header: 'ROLE' },
+        ], (line) => this.log(line));
+        // State what "none selected" MEANS. An unmarked list reads as a missing
+        // setting; the honest reading is that sessions land in Personal.
+        if (!current) {
+            this.log(`\n${(0, workspaces_1.describeUnselectedWorkspace)(listing)}`);
+            this.log('Choose one explicitly with `skrr workspaces use <id>`.');
+        }
+    }
+}
+exports.default = WorkspacesList;

package/dist/commands/workspaces/use.d.ts

@@ -0,0 +1,25 @@
+import { BaseCommand } from '../../base-command';
+/**
+ * Choose the workspace this machine works in — once.
+ *
+ * Before this, workspace was the one axis the CLI made you re-declare on every
+ * invocation. User identity is not handled that way: `skrr login` once and every
+ * request carries it. This is the same shape for the other axis.
+ *
+ * What it does NOT do is decide billing. The selection picks which agent
+ * `skrr code` resolves — the default-agent identity is `(author, workspace,
+ * harness)` — and the server bills the AGENT's own workspace. Keeping one truth
+ * source is what stops a session billing a workspace its agent is not in.
+ */
+export default class WorkspacesUse extends BaseCommand {
+    static description: string;
+    static examples: string[];
+    static args: {
+        workspace: import("@oclif/core/lib/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static flags: {
+        clear: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        json: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/workspaces/use.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@oclif/core");
+const base_command_1 = require("../../base-command");
+const config_1 = require("../../lib/config");
+const workspaces_1 = require("../../lib/workspaces");
+/**
+ * Choose the workspace this machine works in — once.
+ *
+ * Before this, workspace was the one axis the CLI made you re-declare on every
+ * invocation. User identity is not handled that way: `skrr login` once and every
+ * request carries it. This is the same shape for the other axis.
+ *
+ * What it does NOT do is decide billing. The selection picks which agent
+ * `skrr code` resolves — the default-agent identity is `(author, workspace,
+ * harness)` — and the server bills the AGENT's own workspace. Keeping one truth
+ * source is what stops a session billing a workspace its agent is not in.
+ */
+class WorkspacesUse extends base_command_1.BaseCommand {
+    static description = 'Set the workspace this machine works in (persisted; --workspace still wins per command)';
+    static examples = [
+        '<%= config.bin %> workspaces use acme-eng',
+        '<%= config.bin %> workspaces use ws_01H8XK…',
+        '<%= config.bin %> workspaces use --clear',
+    ];
+    static args = {
+        workspace: core_1.Args.string({ ignoreStdin: true, description: 'Workspace id, slug, or name' }),
+    };
+    static flags = {
+        clear: core_1.Flags.boolean({ description: 'Forget the selection and go back to Personal' }),
+        json: core_1.Flags.boolean({ description: 'Output as JSON' }),
+    };
+    async run() {
+        this.requireAuth();
+        const { args, flags } = await this.parse(WorkspacesUse);
+        if (flags.clear) {
+            const config = (0, config_1.loadConfig)();
+            delete config.workspaceId;
+            (0, config_1.saveConfig)(config);
+            (0, config_1.clearSelectedWorkspaceCache)();
+            if (flags.json) {
+                this.log(JSON.stringify({ workspaceId: null }, null, 2));
+                return;
+            }
+            this.log('Workspace selection cleared. Sessions resolve to your default workspace — ' +
+                '`skrr workspaces list` names which one.');
+            return;
+        }
+        if (!args.workspace) {
+            this.error('Name a workspace, or pass --clear to forget the current one.', { exit: 1 });
+            return;
+        }
+        let rows;
+        try {
+            rows = await (0, workspaces_1.listWorkspaces)();
+        }
+        catch (err) {
+            this.handleApiError(err);
+            return;
+        }
+        // Resolved against the caller's OWN memberships. Storing a workspace you are
+        // not in would attach a header the server refuses to every later request,
+        // and the failure would surface nowhere near this command.
+        const matches = (0, workspaces_1.matchWorkspace)(rows, args.workspace);
+        if (matches.length === 0) {
+            const available = rows.map((row) => `  ${row.id}  ${row.name ?? ''}`.trimEnd()).join('\n');
+            this.error(`No workspace of yours matches "${args.workspace}".` +
+                (available ? `\n\nWorkspaces you belong to:\n${available}` : ''), { exit: 1 });
+            return;
+        }
+        // Two workspaces can carry the same display name. Picking one silently would
+        // point this machine's whole session history at the wrong team.
+        if (matches.length > 1) {
+            const ambiguous = matches.map((row) => `  ${row.id}  ${row.name ?? ''}`.trimEnd()).join('\n');
+            this.error(`"${args.workspace}" matches more than one workspace:\n${ambiguous}\n\nUse the id.`, {
+                exit: 1,
+            });
+            return;
+        }
+        const selected = matches[0];
+        const config = (0, config_1.loadConfig)();
+        config.workspaceId = selected.id;
+        (0, config_1.saveConfig)(config);
+        (0, config_1.clearSelectedWorkspaceCache)();
+        if (flags.json) {
+            this.log(JSON.stringify({ workspaceId: selected.id, name: selected.name ?? null }, null, 2));
+            return;
+        }
+        this.log(`Now working in ${selected.name ?? selected.id} (${selected.id}).`);
+        this.log('New agents and `skrr code` sessions resolve here. --workspace still wins per command.');
+    }
+}
+exports.default = WorkspacesUse;

package/dist/hooks/command-not-found.d.ts

@@ -0,0 +1,3 @@
+import { Hook } from '@oclif/core';
+declare const hook: Hook<'command_not_found'>;
+export default hook;

package/dist/hooks/command-not-found.js

@@ -0,0 +1,171 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_manifest_1 = require("../lib/command-manifest");
+const usage_discovery_1 = require("../lib/usage-discovery");
+/**
+ * Turn "command not found" back into the truth when the command DOES exist.
+ *
+ * ── The failure ───────────────────────────────────────────────────────────
+ *
+ * oclif resolves a command by joining argv with `:`, so an unexpected
+ * positional becomes part of the command id:
+ *
+ *     $ skrr shortcuts list 4a167054-e70e-4b1c-ab43-88de52d3d4a2
+ *      ›   Error: command shortcuts:list:4a167054-… not found
+ *
+ * `skrr shortcuts list` exists and is correct — only the argument form was
+ * wrong; it wants `--space`. But the message says the COMMAND is missing, which
+ * is the one conclusion that sends a reader looking in the wrong place. I hit
+ * the identical shape on `skrr commitments archive <id>` and briefly believed
+ * the subcommand had been removed.
+ *
+ * It is easy to hit because the CLI has no rule about how a space is passed:
+ * 65 commands take it as a positional and 61 as `--space`, and `projects
+ * create <SPACE>` sits beside `projects archive --space`. Picking one is a
+ * separate, larger change (OSK-4527). This makes guessing wrong cheap either
+ * way, which is worth having even after that lands.
+ *
+ * ── What it does ──────────────────────────────────────────────────────────
+ *
+ * Walks the id's prefixes longest-first. If one resolves to a real command, the
+ * remaining tokens are arguments that command did not want, and the message
+ * says so — naming the command, the leftover tokens, and the flag to try when
+ * the command has an obvious one. Otherwise it falls through to oclif's own
+ * not-found behaviour, because then the command really is missing.
+ */
+/** A uuid-ish token, which is what a stray space id looks like. */
+const LOOKS_LIKE_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const hook = async function (opts) {
+    const id = String(opts.id ?? '');
+    const parts = id.split(':').filter(Boolean);
+    // `skrr usage tasks` is the canonical form because it has a real command and
+    // consequently receives normal oclif flag validation. Let people discover
+    // a domain in the more conversational `skrr tasks usage` form too, without
+    // generating a second command file for every manifest domain. Existing
+    // domain-owned `usage` commands (balance, daemon, harnesses) never reach
+    // this hook, so their established API behaviour remains untouched.
+    if (parts.length === 2 && parts[1] === 'usage' && this.config.root) {
+        try {
+            const manifest = (0, command_manifest_1.loadCommandManifest)(this.config.root);
+            const parsed = virtualUsageFlags(process.argv.slice(2));
+            const reference = (0, usage_discovery_1.buildUsageReference)(manifest, parts[0], {
+                bin: this.config.bin,
+                page: parsed.page,
+            });
+            if (reference) {
+                process.stdout.write(`${parsed.json ? JSON.stringify(reference, null, 2) : (0, usage_discovery_1.renderUsageReference)(reference, this.config.bin)}\n`);
+                return;
+            }
+        }
+        catch (err) {
+            // A broken manifest should retain the regular command-not-found response
+            // rather than making a typo look like a successful, partial reference.
+            // Invalid virtual usage flags are actionable though, and should not be
+            // swallowed into an unrelated "not a command" diagnostic.
+            if (err instanceof VirtualUsageFlagError)
+                throw err;
+        }
+    }
+    // Longest prefix first: `a:b:c` should report `a b`, not `a`.
+    for (let take = parts.length - 1; take >= 1; take -= 1) {
+        const candidateId = parts.slice(0, take).join(':');
+        const found = this.config.findCommand(candidateId);
+        if (!found)
+            continue;
+        const extras = parts.slice(take);
+        const spoken = `${this.config.bin} ${parts.slice(0, take).join(' ')}`;
+        // Suggest the flag only when the command actually has it, so the hint can
+        // never point at something that does not exist.
+        const flags = Object.keys(found.flags ?? {});
+        const hint = extras.some((e) => LOOKS_LIKE_ID.test(e)) && flags.includes('space')
+            ? ` Pass it as \`--space ${extras[0]}\`.`
+            : flags.includes('space')
+                ? ' It takes `--space <id>`.'
+                : '';
+        const plural = extras.length === 1 ? 'argument' : 'arguments';
+        throw new Error(`\`${spoken}\` exists, but does not take the positional ${plural} ` +
+            `${extras.map((e) => `\`${e}\``).join(' ')}.${hint}\n` +
+            `See \`${spoken} --help\`.`);
+    }
+    // No prefix resolved — the command genuinely is not there.
+    //
+    // This branch MUST throw. A `command_not_found` hook that returns without
+    // throwing is treated as having handled the miss, so oclif prints nothing and
+    // exits 0 — a typo would silently look like success, which is far worse than
+    // the message this hook was written to improve. (I shipped exactly that for
+    // one build; `skrr shortcuts lst` said nothing and exited 0.)
+    const allIds = this.config.commandIDs.map((c) => String(c));
+    // Topic names are candidates too, so a near-miss on a bare topic gets routed
+    // to the topic rather than nothing (OSK-4869): `skrr harness` (singular) is
+    // one edit from the `harnesses` topic, but that topic owns no command whose
+    // id is close to `harness`, so a command-id-only search suggests nothing.
+    const topics = this.config.topics;
+    const topicNames = Array.isArray(topics)
+        ? topics.map((t) => String(t?.name ?? '')).filter(Boolean)
+        : [];
+    // Prefer siblings under the same topic. `commitments:archive:<id>` is a long
+    // way from every real command id, so a whole-string comparison finds nothing
+    // and the reader is told only that they are wrong — when the useful answer is
+    // "that topic exists and here is what it does have".
+    const topic = parts[0];
+    const siblings = allIds.filter((c) => c.startsWith(`${topic}:`));
+    const suggestions = siblings.length
+        ? nearestCommands(parts.slice(0, 2).join(':'), siblings)
+        : nearestCommands(id, [...allIds, ...topicNames]);
+    throw new Error(`\`${this.config.bin} ${parts.join(' ')}\` is not a command.` +
+        (suggestions.length
+            ? `\nDid you mean: ${suggestions.map((s) => `\`${this.config.bin} ${s.split(':').join(' ')}\``).join(', ')}?`
+            : `\nRun \`${this.config.bin} --help\` to see the topics.`));
+};
+/** Cheap edit distance, bounded — this runs only on a miss. */
+function editDistance(a, b) {
+    const rows = a.length + 1;
+    const cols = b.length + 1;
+    let prev = Array.from({ length: cols }, (_, j) => j);
+    for (let i = 1; i < rows; i += 1) {
+        const cur = [i, ...Array(cols - 1).fill(0)];
+        for (let j = 1; j < cols; j += 1) {
+            cur[j] = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+        }
+        prev = cur;
+    }
+    return prev[cols - 1];
+}
+/**
+ * The closest real command ids, so a typo gets a route forward rather than
+ * only a verdict.
+ */
+function nearestCommands(id, all, limit = 3) {
+    return (all
+        .map((candidate) => ({ candidate, d: editDistance(id, candidate) }))
+        // A third of the length keeps this to genuine near-misses; without a bound
+        // every miss suggests three unrelated commands, which is noise wearing the
+        // shape of help.
+        .filter(({ d }) => d <= Math.max(2, Math.floor(id.length / 3)))
+        .sort((x, y) => x.d - y.d)
+        .slice(0, limit)
+        .map(({ candidate }) => candidate));
+}
+exports.default = hook;
+class VirtualUsageFlagError extends Error {
+}
+function virtualUsageFlags(argv) {
+    let json = false;
+    let page = 1;
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === '--json') {
+            json = true;
+            continue;
+        }
+        const suppliedPage = token === '--page' ? argv[++index] : token.match(/^--page=(.+)$/)?.[1];
+        if (suppliedPage !== undefined) {
+            const parsed = Number(suppliedPage);
+            if (!Number.isInteger(parsed) || parsed < 1) {
+                throw new VirtualUsageFlagError('`--page` must be a positive integer.');
+            }
+            page = parsed;
+        }
+    }
+    return { json, page };
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export { run } from '@oclif/core';

package/dist/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+// Entry point for programmatic use. Most consumers will use the CLI binary
+// defined in bin/run.js (currently shipped as `skrr`), which discovers
+// commands from dist/commands.
+var core_1 = require("@oclif/core");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return core_1.run; } });

package/dist/lib/action-listings.d.ts

@@ -0,0 +1,5 @@
+import type { ActionListing } from '@skrr-ai/data-provider';
+export declare const ACTION_LISTING_CATEGORIES: readonly ["code", "data", "research", "content", "communication", "productivity", "ai", "creative", "enterprise", "other"];
+export declare const ACTION_LISTING_SORTS: readonly ["installCount", "rating", "createdAt", "price"];
+export declare function renderActionListings(listings: ActionListing[], log: (line: string) => void): void;
+export declare function renderActionListing(listing: ActionListing, log: (line: string) => void): void;

package/dist/lib/action-listings.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTION_LISTING_SORTS = exports.ACTION_LISTING_CATEGORIES = void 0;
+exports.renderActionListings = renderActionListings;
+exports.renderActionListing = renderActionListing;
+const format_1 = require("./format");
+exports.ACTION_LISTING_CATEGORIES = [
+    'code',
+    'data',
+    'research',
+    'content',
+    'communication',
+    'productivity',
+    'ai',
+    'creative',
+    'enterprise',
+    'other',
+];
+exports.ACTION_LISTING_SORTS = ['installCount', 'rating', 'createdAt', 'price'];
+function renderActionListings(listings, log) {
+    if (listings.length === 0) {
+        log('No action listings found.');
+        return;
+    }
+    (0, format_1.renderTable)(listings.map((listing) => ({
+        id: listing.id,
+        name: listing.displayName || listing.name,
+        kind: listing.kind,
+        category: listing.category,
+        public: listing.isPublic ? 'yes' : 'no',
+        installs: String(listing.installCount ?? 0),
+        rating: listing.ratingCount ? `${listing.rating.toFixed(1)} (${listing.ratingCount})` : '-',
+    })), [
+        { key: 'id', header: 'ID', verbatim: true },
+        { key: 'name', header: 'Name', maxWidth: 32 },
+        { key: 'kind', header: 'Kind' },
+        { key: 'category', header: 'Category' },
+        { key: 'public', header: 'Public' },
+        { key: 'installs', header: 'Installs' },
+        { key: 'rating', header: 'Rating' },
+    ], log);
+}
+function renderActionListing(listing, log) {
+    log(`ID:          ${listing.id}`);
+    log(`Name:        ${listing.displayName || listing.name}`);
+    log(`Slug:        ${listing.name}`);
+    log(`Kind:        ${listing.kind}`);
+    log(`Category:    ${listing.category}`);
+    log(`Public:      ${listing.isPublic ? 'yes' : 'no'}`);
+    log(`Price:       ${listing.price ?? 0}`);
+    log(`Installs:    ${listing.installCount ?? 0}`);
+    log(`Rating:      ${listing.ratingCount ? `${listing.rating} (${listing.ratingCount})` : '-'}`);
+    if (listing.builtinType)
+        log(`Builtin:     ${listing.builtinType}`);
+    if (listing.description) {
+        log('');
+        log('Description:');
+        log(listing.description);
+    }
+    if (listing.prompt) {
+        log('');
+        log('Prompt:');
+        log(listing.prompt);
+    }
+    if (listing.configTemplate) {
+        log('');
+        log('Config template:');
+        log(JSON.stringify(listing.configTemplate, null, 2));
+    }
+}

package/dist/lib/agent-actions.d.ts

@@ -0,0 +1,35 @@
+import type { Agent, AgentAction, BuiltinActionConfig, BuiltinActionType, BuiltinAgentAction, EmbeddedActionRef, PromptAgentAction } from '@skrr-ai/data-provider';
+export declare const BUILTIN_ACTION_TYPES: readonly ["slack_send_message", "slack_tool", "group_chat_message", "space_create_task", "space_post_update", "task_create", "task_mark_done", "task_assign", "goal_create", "goal_mark_done", "smart_schedule_plan", "smart_schedule_delta_watch"];
+export declare const ACTION_TARGET_TYPES: readonly ["group-chats", "spaces", "tasks", "goals", "slack-channels", "slack-users"];
+export type ActionTargetType = (typeof ACTION_TARGET_TYPES)[number];
+export declare function parseJsonObjectFlag(value: string | undefined, flagName: string): Record<string, unknown> | undefined;
+export declare function fetchAgentForActionEdit(agentId: string): Promise<Agent>;
+export declare function getAgentActions(agent: Agent): AgentAction[];
+export declare function findAgentAction(agent: Agent, actionId: string): AgentAction | undefined;
+export declare function updateAgentActions(agentId: string, actions: AgentAction[]): Promise<Agent>;
+export declare function makePromptAction(input: {
+    title: string;
+    description?: string;
+    prompt: string;
+    order: number;
+    enabled: boolean;
+    id?: string;
+    sourceListingId?: string;
+    /** Structured built-in actions embedded in the prompt — the chip source of truth. */
+    embeddedActions?: EmbeddedActionRef[];
+}): PromptAgentAction;
+export declare function makeBuiltinAction(input: {
+    title: string;
+    description?: string;
+    builtinType: BuiltinActionType;
+    config: BuiltinActionConfig | Record<string, unknown>;
+    prompt?: string;
+    order: number;
+    enabled: boolean;
+    id?: string;
+    sourceListingId?: string;
+}): BuiltinAgentAction;
+export declare function nextActionOrder(actions: AgentAction[]): number;
+export declare function actionKind(action: AgentAction): 'prompt' | 'builtin';
+export declare function renderActions(actions: AgentAction[], log: (line: string) => void): void;
+export declare function renderAction(action: AgentAction, log: (line: string) => void): void;

package/dist/lib/agent-actions.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACTION_TARGET_TYPES = exports.BUILTIN_ACTION_TYPES = void 0;
+exports.parseJsonObjectFlag = parseJsonObjectFlag;
+exports.fetchAgentForActionEdit = fetchAgentForActionEdit;
+exports.getAgentActions = getAgentActions;
+exports.findAgentAction = findAgentAction;
+exports.updateAgentActions = updateAgentActions;
+exports.makePromptAction = makePromptAction;
+exports.makeBuiltinAction = makeBuiltinAction;
+exports.nextActionOrder = nextActionOrder;
+exports.actionKind = actionKind;
+exports.renderActions = renderActions;
+exports.renderAction = renderAction;
+const node_crypto_1 = require("node:crypto");
+const data_provider_1 = require("@skrr-ai/data-provider");
+const format_1 = require("./format");
+exports.BUILTIN_ACTION_TYPES = [
+    'slack_send_message',
+    'slack_tool',
+    'group_chat_message',
+    'space_create_task',
+    'space_post_update',
+    'task_create',
+    'task_mark_done',
+    'task_assign',
+    'goal_create',
+    'goal_mark_done',
+    'smart_schedule_plan',
+    'smart_schedule_delta_watch',
+];
+const _builtinActionTypesAreExhaustive = true;
+void _builtinActionTypesAreExhaustive;
+exports.ACTION_TARGET_TYPES = [
+    'group-chats',
+    'spaces',
+    'tasks',
+    'goals',
+    'slack-channels',
+    'slack-users',
+];
+function parseJsonObjectFlag(value, flagName) {
+    if (value === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`${flagName} must be valid JSON: ${message}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`${flagName} must be a JSON object.`);
+    }
+    return parsed;
+}
+async function fetchAgentForActionEdit(agentId) {
+    return data_provider_1.dataService.getExpandedAgentById({ agent_id: agentId });
+}
+function getAgentActions(agent) {
+    return Array.isArray(agent.agentActions) ? [...agent.agentActions] : [];
+}
+function findAgentAction(agent, actionId) {
+    return getAgentActions(agent).find((action) => action.id === actionId);
+}
+async function updateAgentActions(agentId, actions) {
+    return data_provider_1.dataService.updateAgent({
+        agent_id: agentId,
+        data: { agentActions: actions },
+    });
+}
+function makePromptAction(input) {
+    return {
+        id: input.id ?? (0, node_crypto_1.randomUUID)(),
+        title: input.title,
+        description: input.description,
+        order: input.order,
+        enabled: input.enabled,
+        prompt: input.prompt,
+        ...(input.embeddedActions && input.embeddedActions.length > 0
+            ? { embeddedActions: input.embeddedActions }
+            : {}),
+        ...(input.sourceListingId ? { sourceListingId: input.sourceListingId } : {}),
+    };
+}
+function makeBuiltinAction(input) {
+    return {
+        id: input.id ?? (0, node_crypto_1.randomUUID)(),
+        kind: 'builtin',
+        title: input.title,
+        description: input.description,
+        order: input.order,
+        enabled: input.enabled,
+        builtinType: input.builtinType,
+        config: input.config,
+        ...(input.prompt ? { prompt: input.prompt } : {}),
+        ...(input.sourceListingId ? { sourceListingId: input.sourceListingId } : {}),
+    };
+}
+function nextActionOrder(actions) {
+    if (actions.length === 0)
+        return 0;
+    return Math.max(...actions.map((action) => Number(action.order) || 0)) + 1;
+}
+function actionKind(action) {
+    return action.kind === 'builtin' ? 'builtin' : 'prompt';
+}
+function renderActions(actions, log) {
+    if (actions.length === 0) {
+        log('No agent actions configured.');
+        return;
+    }
+    (0, format_1.renderTable)(actions
+        .slice()
+        .sort((a, b) => a.order - b.order)
+        .map((action) => ({
+        id: action.id,
+        title: action.title,
+        kind: actionKind(action),
+        enabled: action.enabled === false ? 'no' : 'yes',
+        target: action.kind === 'builtin'
+            ? action.builtinType
+            : `${(action.prompt || '').trim().length} chars`,
+        order: String(action.order),
+    })), [
+        { key: 'id', header: 'ID', verbatim: true },
+        { key: 'title', header: 'Title', maxWidth: 30 },
+        { key: 'kind', header: 'Kind' },
+        { key: 'target', header: 'Target', maxWidth: 24 },
+        { key: 'enabled', header: 'On' },
+        { key: 'order', header: 'Order' },
+    ], log);
+}
+function renderAction(action, log) {
+    log(`ID:          ${action.id}`);
+    log(`Title:       ${action.title}`);
+    log(`Kind:        ${actionKind(action)}`);
+    log(`Enabled:     ${action.enabled === false ? 'no' : 'yes'}`);
+    log(`Order:       ${action.order}`);
+    if (action.description) {
+        log(`Description: ${action.description}`);
+    }
+    if (action.sourceListingId) {
+        log(`Listing:     ${action.sourceListingId}`);
+    }
+    if (action.kind === 'builtin') {
+        log(`Builtin:     ${action.builtinType}`);
+        log('');
+        log('Config:');
+        log(JSON.stringify(action.config ?? {}, null, 2));
+        if (action.prompt) {
+            log('');
+            log('Prompt:');
+            log(action.prompt);
+        }
+        return;
+    }
+    log('');
+    log('Prompt:');
+    log(action.prompt || '');
+}

package/dist/lib/agent-config.d.ts

@@ -0,0 +1,2 @@
+/** Apply the structured agent fields exposed by the web config editor. */
+export declare function mergeAgentConfigFlags(body: Record<string, unknown>, flags: Record<string, unknown>): Record<string, unknown>;