@metrio-ai/cli 1.0.1 → 1.2.0

package/dist/manage/schema.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propFromFlag = exports.kebab = void 0;
+exports.propertyTypes = propertyTypes;
+exports.coercePositional = coercePositional;
+exports.resolveFlags = resolveFlags;
+exports.dropUnaccepted = dropUnaccepted;
+exports.validateArgs = validateArgs;
+const _2020_1 = __importDefault(require("ajv/dist/2020"));
+const errors_1 = require("../errors");
+const input_1 = require("./input");
+const kebab = (prop) => prop.replace(/_/g, '-');
+exports.kebab = kebab;
+const propFromFlag = (flag) => flag.replace(/-/g, '_');
+exports.propFromFlag = propFromFlag;
+/** The JSON types a property accepts, flattening `anyOf`. Empty = unknown (treated as string). */
+function propertyTypes(schema) {
+    if (Array.isArray(schema.type))
+        return schema.type;
+    if (typeof schema.type === 'string')
+        return [schema.type];
+    return (schema.anyOf ?? []).flatMap(propertyTypes);
+}
+const isBooleanOnly = (types) => types.length > 0 && types.every((t) => t === 'boolean');
+function coerce(name, raw, prop, readStdin) {
+    const types = propertyTypes(prop);
+    if (raw === 'null' && types.includes('null'))
+        return null;
+    if (types.includes('boolean') && (raw === 'true' || raw === 'false'))
+        return raw === 'true';
+    if (types.includes('number') || types.includes('integer')) {
+        const n = Number(raw);
+        if (raw.trim() === '' || Number.isNaN(n))
+            throw new errors_1.CliError(`${name} must be a number, got "${raw}"`);
+        return n;
+    }
+    if (types.includes('object') || types.includes('array')) {
+        if (raw.startsWith('@')) {
+            const loaded = (0, input_1.loadInputFile)(raw.slice(1), readStdin);
+            if (loaded.kind === 'text')
+                throw new errors_1.CliError(`${name}: ${raw.slice(1)} must be .json or .yaml`);
+            return loaded.value;
+        }
+        try {
+            return JSON.parse(raw);
+        }
+        catch (err) {
+            throw new errors_1.CliError(`${name} must be valid JSON (or @file): ${err.message}`);
+        }
+    }
+    if (types.includes('boolean'))
+        throw new errors_1.CliError(`${name} must be true or false, got "${raw}"`);
+    if (raw.startsWith('@@'))
+        return raw.slice(1);
+    return raw.startsWith('@') ? (0, input_1.readText)(raw.slice(1), readStdin) : raw;
+}
+function coercePositional(raw, prop, label) {
+    if (!prop || (raw.startsWith('@') && !propertyTypes(prop).some((t) => ['number', 'integer', 'object', 'array'].includes(t))))
+        return raw;
+    return coerce(label, raw, prop);
+}
+/**
+ * Turns `--field value` tokens into tool arguments typed by the schema. A bare boolean flag
+ * never consumes the next token unless it is literally true/false.
+ */
+function resolveFlags(tokens, schema, readStdin) {
+    const props = schema.properties ?? {};
+    const values = {};
+    const positionals = [];
+    const accepted = () => Object.keys(props).map((p) => `--${(0, exports.kebab)(p)}`).join(', ') || '(none)';
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i];
+        if (token.flag === undefined) {
+            positionals.push(token.positional);
+            continue;
+        }
+        let prop = (0, exports.propFromFlag)(token.flag);
+        let negated = false;
+        if (!(prop in props) && token.flag.startsWith('no-') && (0, exports.propFromFlag)(token.flag.slice(3)) in props) {
+            prop = (0, exports.propFromFlag)(token.flag.slice(3));
+            negated = true;
+        }
+        const propSchema = props[prop];
+        if (!propSchema)
+            throw new errors_1.CliError(`Unknown option --${token.flag}. Accepted fields: ${accepted()}`);
+        const name = `--${(0, exports.kebab)(prop)}`;
+        const types = propertyTypes(propSchema);
+        if (negated) {
+            if (!types.includes('boolean'))
+                throw new errors_1.CliError(`--${token.flag}: ${name} is not a boolean`);
+            values[prop] = false;
+            continue;
+        }
+        let raw = token.value;
+        if (raw === undefined) {
+            const next = tokens[i + 1];
+            const nextIsValue = next !== undefined && next.flag === undefined;
+            if (isBooleanOnly(types) && !(nextIsValue && (next.positional === 'true' || next.positional === 'false'))) {
+                values[prop] = true;
+                continue;
+            }
+            if (!nextIsValue)
+                throw new errors_1.CliError(`${name} needs a value`);
+            raw = next.positional;
+            i += 1;
+        }
+        values[prop] = coerce(name, raw, propSchema, readStdin);
+    }
+    return { values, positionals };
+}
+/** Removes keys the tool does not declare and null values for properties that do not accept null. */
+function dropUnaccepted(args, schema) {
+    const props = schema.properties ?? {};
+    const kept = {};
+    const dropped = [];
+    for (const [key, value] of Object.entries(args)) {
+        const prop = props[key];
+        const types = prop ? propertyTypes(prop) : [];
+        if (!prop || (value === null && types.length > 0 && !types.includes('null')))
+            dropped.push(key);
+        else
+            kept[key] = value;
+    }
+    return { args: kept, dropped };
+}
+const ajv = new _2020_1.default({ allErrors: true, strict: false });
+const validators = new Map();
+function describeError(error, sources) {
+    if (error.keyword === 'required') {
+        return `  ${error.params.missingProperty} (missing): is required`;
+    }
+    const field = error.instancePath.replace(/^\//, '').replace(/\//g, '.') || '(root)';
+    const top = field.split('.')[0];
+    const source = sources[top] ?? 'input';
+    return `  ${field} (${source}): ${error.message ?? 'is invalid'}`;
+}
+/** Validates against the tool's JSON Schema; errors list every field with where it came from. */
+function validateArgs(tool, args, schema, sources) {
+    const key = `${tool}:${JSON.stringify(schema)}`;
+    let validate = validators.get(key);
+    if (!validate) {
+        validate = ajv.compile(schema);
+        validators.set(key, validate);
+    }
+    if (validate(args))
+        return;
+    const lines = Array.from(new Set((validate.errors ?? []).map((e) => describeError(e, sources))));
+    throw new errors_1.CliError(`Invalid input for ${tool}:\n${lines.join('\n')}`, 2);
+}

package/dist/sync/push.js

@@ -0,0 +1,329 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.versionContent = versionContent;
+exports.hasPendingVersion = hasPendingVersion;
+exports.pushEntry = pushEntry;
+exports.deleteEntry = deleteEntry;
+const crypto_1 = require("crypto");
+const errors_1 = require("../errors");
+const remote_1 = require("./remote");
+const render_1 = require("./render");
+const defined = (o) => Object.fromEntries(Object.entries(o).filter(([, v]) => v !== undefined));
+async function call(ctx, tool, args) {
+    return ((await ctx.client.callTool(tool, defined({ project_slug: ctx.project, ...args }))) ?? {});
+}
+const sha = (text) => (0, crypto_1.createHash)('sha256').update(text).digest('hex');
+const message = (err) => (err instanceof Error ? err.message : String(err));
+/** Best-effort removal of a resource this push just created, so a failed push leaves no orphan. */
+async function undoCreate(ctx, tool, args, what, error) {
+    try {
+        await call(ctx, tool, args);
+        return new errors_1.CliError(`${message(error)} (the half-created ${what.split(' ')[0]} was removed)`);
+    }
+    catch (cleanup) {
+        return new errors_1.CliError(`${message(error)} (cleanup failed: ${message(cleanup)}; ${what} exists in the console)`);
+    }
+}
+/*
+ * When does a push create a version?
+ *
+ * The console normalizes what it stores: create_version fills in output_format and
+ * model_settings defaults and stores an empty model_fallbacks as null; creating or
+ * publishing a workflow version pins its prompt_ref tags. So right after a push the
+ * re-read remote can differ from the local files although nobody edited anything, and
+ * comparing local with remote alone would create a new version on every later push and
+ * every --activate.
+ *
+ * So every push records two hashes of the version content (a prompt's versionPart, a
+ * workflow's canonical definition) in state:
+ *   pushed_content  the local content of the last version this workspace pushed
+ *   remote_content  the remote live content re-read right after the last push
+ * While both still match ("untouched since the push"), neither side changed version
+ * content, and any remaining local/remote difference is console normalization: no new
+ * version. The one exception is a pending version: one this workspace pushed
+ * (pushed_version_id / pushed_workflow_version) that is not the live one (prompt head /
+ * active workflow version), still holding the local content. --activate (or --publish
+ * for a workflow) makes it live; a plain push only reports it.
+ */
+/** sha of the version content of rendered/local files; undefined for skills (unversioned). */
+function versionContent(kind, files, where) {
+    if (kind === 'prompt')
+        return sha((0, render_1.versionPart)((0, render_1.parsePrompt)(files, where)));
+    if (kind === 'workflow')
+        return sha((0, render_1.canonical)((0, render_1.parseWorkflow)(files, where).definition));
+    return undefined;
+}
+const untouchedSincePush = (e, localContent, remoteContent) => e.state?.pushed_content === localContent && e.state.remote_content === remoteContent;
+/** The pushed version that is not live, if it still holds the local content. */
+function pendingVersion(e, localContent) {
+    const s = e.state;
+    if (!s || !e.remote || s.pushed_content !== localContent)
+        return undefined;
+    if (e.kind === 'prompt') {
+        const head = e.remote.data.version?.id;
+        return s.pushed_version_id !== undefined && s.pushed_version_id !== head ? s.pushed_version_id : undefined;
+    }
+    const active = e.remote.data.active_version;
+    return s.pushed_workflow_version !== undefined && s.pushed_workflow_version !== active ? s.pushed_workflow_version : undefined;
+}
+/** An unchanged entry holding a pending version (see above) that these flags should make live. */
+function hasPendingVersion(e, options) {
+    if (!e.local || !e.remote || !e.state)
+        return false;
+    const wanted = e.kind === 'prompt' ? options.activate : e.kind === 'workflow' && (options.activate || options.publish);
+    if (!wanted)
+        return false;
+    try {
+        return pendingVersion(e, versionContent(e.kind, e.local, e.key)) !== undefined;
+    }
+    catch {
+        return false; // unparsable files: a plain push reports the error
+    }
+}
+async function skillId(ctx, name, where) {
+    if (!ctx.skillIds) {
+        const rows = await (0, remote_1.fetchAll)(ctx.client, 'list_skills', { project_slug: ctx.project });
+        ctx.skillIds = new Map(rows.map((r) => [String(r.name), Number(r.id)]));
+    }
+    const id = ctx.skillIds.get(name);
+    if (id === undefined)
+        throw new errors_1.CliError(`${where}/prompt.yaml: unknown skill "${name}"`);
+    return id;
+}
+function modelArgs(doc) {
+    if (doc.model?.tier)
+        return { tier_key: doc.model.tier };
+    return { model_provider: doc.model?.provider, model_name: doc.model?.name };
+}
+function assertVersionable(doc, key) {
+    const m = doc.model;
+    if (!m || !(m.tier || (m.provider && m.name))) {
+        throw new errors_1.CliError(`${key}/prompt.yaml: "model" must be { provider, name } or { tier } to create a version`);
+    }
+    if (!doc.system.trim())
+        throw new errors_1.CliError(`${key}/system.md is empty`);
+}
+/** A new version is built from files only: refuse to silently drop what files cannot carry. */
+function assertNoDroppedHeadFields(e) {
+    const head = e.remote.data.version;
+    const messages = head?.messages;
+    const agentDescription = head?.agent_description;
+    if ((Array.isArray(messages) && messages.length > 0) || (typeof agentDescription === 'string' && agentDescription !== '')) {
+        throw new errors_1.CliError(`${e.key}: the live version has messages/agent_description that files cannot carry; a new version would drop them (use --force to proceed)`);
+    }
+}
+async function pushPrompt(ctx, e) {
+    const local = (0, render_1.parsePrompt)(e.local, e.key);
+    const remote = e.remote ? (0, render_1.parsePrompt)(e.remote.files, e.key) : undefined;
+    const { activate, message: description } = ctx.options;
+    const content = sha((0, render_1.versionPart)(local));
+    // See "When does a push create a version?" above.
+    let createVersion = !remote;
+    let pending;
+    if (remote && (0, render_1.versionPart)(local) !== (0, render_1.versionPart)(remote)) {
+        if (untouchedSincePush(e, content, sha((0, render_1.versionPart)(remote)))) {
+            pending = pendingVersion(e, content);
+            createVersion = pending !== undefined && activate;
+        }
+        else
+            createVersion = true;
+    }
+    // Everything that can fail locally is checked before any write.
+    const ids = new Map();
+    for (const name of new Set([...local.skills, ...(remote?.skills ?? [])]))
+        ids.set(name, await skillId(ctx, name, e.key));
+    if (createVersion)
+        assertVersionable(local, e.key);
+    if (createVersion && remote && !ctx.options.force)
+        assertNoDroppedHeadFields(e);
+    let id = e.remote?.id ?? e.state?.id;
+    let created = false;
+    if (!id) {
+        const row = await call(ctx, 'create_prompt', { name: local.name, description: local.description });
+        id = String(row.external_id);
+        created = true;
+    }
+    else if (remote && (local.name !== remote.name || (local.description ?? '') !== (remote.description ?? ''))) {
+        await call(ctx, 'update_prompt', { prompt_external_id: Number(id), name: local.name, description: local.description ?? '' });
+    }
+    const promptId = Number(id);
+    const result = { id, summary: 'no new version' };
+    try {
+        if (createVersion) {
+            const head = activate || !remote;
+            const v = await call(ctx, 'create_version', {
+                prompt_external_id: promptId,
+                system_prompt: local.system,
+                ...modelArgs(local),
+                output_format: local.output_format,
+                model_settings: local.model_settings,
+                model_fallbacks: local.model_fallbacks,
+                output_schema: local.output_schema,
+                description,
+                set_as_head: head,
+            });
+            result.pushed_version_id = Number(v.id);
+            result.pushed_serial = Number(v.serial);
+            result.pushed_content = content;
+            result.versioned = true;
+            result.summary = `version ${v.serial}${head ? ' (head)' : ''}`;
+        }
+        else if (pending !== undefined) {
+            result.summary = `already pushed as version ${e.state?.pushed_serial} (not live; use --activate)`;
+        }
+        const before = remote?.skills ?? [];
+        for (const name of local.skills.filter((n) => !before.includes(n))) {
+            await call(ctx, 'add_prompt_skill', { prompt_external_id: promptId, skill_id: ids.get(name) });
+        }
+        for (const name of before.filter((n) => !local.skills.includes(n))) {
+            await call(ctx, 'remove_prompt_skill', { prompt_external_id: promptId, skill_id: ids.get(name) });
+        }
+        let remoteMcp = remote?.mcp ?? [];
+        const localIds = local.mcp.map((m) => m.instance_id);
+        const replaced = (0, render_1.canonical)(localIds) !== (0, render_1.canonical)(remoteMcp.map((m) => m.instance_id));
+        if (replaced) {
+            await call(ctx, 'update_prompt', { prompt_external_id: promptId, mcp_instance_ids: localIds });
+            // Replacing the list re-creates every binding with enabled_tools = null.
+            remoteMcp = local.mcp.map((m) => ({ instance_id: m.instance_id, enabled_tools: null }));
+        }
+        // Set every allowlist even if one fails: after a replace, each one not set exposes ALL tools.
+        const failedIds = [];
+        const failures = [];
+        for (const m of local.mcp) {
+            const was = remoteMcp.find((r) => r.instance_id === m.instance_id);
+            const differs = was ? (0, render_1.canonical)(was.enabled_tools) !== (0, render_1.canonical)(m.enabled_tools) : m.enabled_tools !== null;
+            if (!differs)
+                continue;
+            try {
+                await call(ctx, 'set_prompt_mcp_tools', { prompt_external_id: promptId, mcp_instance_id: m.instance_id, enabled_tools: m.enabled_tools });
+            }
+            catch (err) {
+                failedIds.push(m.instance_id);
+                failures.push(`instance ${m.instance_id}: ${message(err)}`);
+            }
+        }
+        if (failedIds.length) {
+            const now = replaced ? 'now expose ALL tools' : 'keep their previous tool allowlist';
+            throw new errors_1.CliError(`${e.key}: MCP instance(s) ${failedIds.join(', ')} ${now} (${failures.join('; ')}); ` +
+                `fix the cause, then run "metrio push --force ${e.key}"`);
+        }
+    }
+    catch (error) {
+        if (created)
+            throw await undoCreate(ctx, 'delete_prompt', { prompt_external_id: promptId }, `prompt ${id}`, error);
+        throw error;
+    }
+    return result;
+}
+async function pushSkill(ctx, e) {
+    const doc = (0, render_1.parseSkill)(e.local['skill.md'], e.key);
+    const existing = e.remote?.id ?? e.state?.id;
+    const fields = { name: doc.name, description: doc.description, content: doc.content, references: doc.references };
+    if (existing) {
+        // Fields missing locally are cleared: the console stores '' as null, which renders as absent.
+        await call(ctx, 'update_skill', {
+            skill_id: Number(existing),
+            ...fields,
+            description: doc.description ?? '',
+            references: doc.references ?? [],
+            enabled: doc.enabled ?? true,
+        });
+        return { id: existing, summary: 'updated' };
+    }
+    const created = await call(ctx, 'create_skill', fields);
+    const id = String(created.id);
+    ctx.skillIds?.set(doc.name, Number(id));
+    if (doc.enabled === false) {
+        try {
+            await call(ctx, 'update_skill', { skill_id: Number(id), enabled: false });
+        }
+        catch (error) {
+            throw await undoCreate(ctx, 'delete_skill', { skill_id: Number(id) }, `skill ${id}`, error);
+        }
+    }
+    return { id, summary: 'created' };
+}
+function assertValid(result, key) {
+    if (result.valid === false) {
+        const errors = Array.isArray(result.errors) ? result.errors.map(String).join('; ') : 'invalid definition';
+        throw new errors_1.CliError(`${key}: the console rejected the definition: ${errors}`, 2);
+    }
+}
+async function pushWorkflow(ctx, e) {
+    // Tracked workflows keep their console id even when the directory name had to be sanitized.
+    const wid = e.state?.id ?? e.remote?.id ?? e.key.slice('workflows/'.length);
+    const doc = (0, render_1.parseWorkflow)(e.local, e.key);
+    if (doc.definition.workflow_id !== wid) {
+        const why = e.state || e.remote ? 'the console workflow id' : 'the directory name';
+        throw new errors_1.CliError(`${e.key}/definition.json: workflow_id must be "${wid}" (${why})`);
+    }
+    const remote = e.remote ? (0, render_1.parseWorkflow)(e.remote.files, e.key) : undefined;
+    const { activate, publish, message: description } = ctx.options;
+    const result = { id: wid, summary: 'no new version' };
+    const content = sha((0, render_1.canonical)(doc.definition));
+    let created = false;
+    if (!remote) {
+        assertValid(await call(ctx, 'create_workflow', { definition: doc.definition }), e.key);
+        created = true;
+        result.pushed_content = content;
+        result.versioned = true;
+        result.summary = 'created';
+    }
+    else if ((0, render_1.canonical)(doc.definition) !== (0, render_1.canonical)(remote.definition)) {
+        // See "When does a push create a version?" above.
+        if (untouchedSincePush(e, content, sha((0, render_1.canonical)(remote.definition)))) {
+            const pending = pendingVersion(e, content);
+            // Already pushed as a version: only make it live, never create a duplicate.
+            if (pending !== undefined && (activate || publish)) {
+                await call(ctx, 'publish_workflow_version', { workflow_id: wid, version: pending, activate });
+                result.versioned = true;
+                result.summary = `version ${pending}${activate ? ' (active)' : ' (published)'}`;
+            }
+            else if (pending !== undefined)
+                result.summary = `already pushed as version ${pending} (draft)`;
+        }
+        else {
+            const row = await call(ctx, 'create_workflow_version', { workflow_id: wid, definition: doc.definition, description, activate });
+            assertValid(row, e.key);
+            // The tool answers { valid, version: { version, status, … }, warnings }.
+            const version = row.version?.version;
+            if (typeof version !== 'number' || !Number.isInteger(version)) {
+                throw new errors_1.CliError(`${e.key}: create_workflow_version answered without a version number (${JSON.stringify(row).slice(0, 200)}); ` +
+                    `a version may have been created: check "metrio workflow version list ${wid}"`);
+            }
+            if (publish && !activate)
+                await call(ctx, 'publish_workflow_version', { workflow_id: wid, version });
+            result.pushed_workflow_version = version;
+            result.pushed_content = content;
+            result.versioned = true;
+            result.summary = `version ${version}${activate ? ' (active)' : publish ? ' (published)' : ' (draft)'}`;
+        }
+    }
+    if (remote ? doc.enabled !== remote.enabled : doc.enabled === false) {
+        try {
+            await call(ctx, 'update_workflow', { workflow_id: wid, enabled: doc.enabled });
+        }
+        catch (error) {
+            if (created)
+                throw await undoCreate(ctx, 'delete_workflow', { workflow_id: wid }, `workflow ${wid}`, error);
+            throw error;
+        }
+    }
+    return result;
+}
+function pushEntry(ctx, e) {
+    if (e.kind === 'prompt')
+        return pushPrompt(ctx, e);
+    if (e.kind === 'skill')
+        return pushSkill(ctx, e);
+    return pushWorkflow(ctx, e);
+}
+async function deleteEntry(ctx, e) {
+    const id = e.state.id;
+    if (e.kind === 'prompt')
+        await call(ctx, 'delete_prompt', { prompt_external_id: Number(id) });
+    else if (e.kind === 'skill')
+        await call(ctx, 'delete_skill', { skill_id: Number(id) });
+    else
+        await call(ctx, 'delete_workflow', { workflow_id: id });
+}

package/dist/sync/remote.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchAll = fetchAll;
+exports.fetchRemote = fetchRemote;
+const shared_1 = require("../commands/shared");
+const errors_1 = require("../errors");
+const render_1 = require("./render");
+const CONCURRENCY = 4;
+async function read(client, tool, args) {
+    return client.callTool(tool, args, { retry: true });
+}
+/** Every row of a paginated list tool (limit 100 per page). */
+async function fetchAll(client, tool, args) {
+    const rows = [];
+    for (let pageNo = 1;; pageNo += 1) {
+        const data = (await read(client, tool, { ...args, page: pageNo, limit: 100 }));
+        if (Array.isArray(data))
+            return data;
+        if (typeof data !== 'object' || data === null)
+            throw new errors_1.CliError(`Unexpected response from ${tool}`);
+        const record = data;
+        const key = Array.isArray(record.items) ? 'items' : Object.keys(record).find((k) => Array.isArray(record[k]));
+        rows.push(...(key ? record[key] : []));
+        const pagination = (record.pagination ?? {});
+        if (!pagination.total_pages || pageNo >= pagination.total_pages)
+            return rows;
+    }
+}
+async function fetchPrompts(client, project) {
+    const rows = await fetchAll(client, 'list_prompts', { project_slug: project });
+    return (0, shared_1.mapWithConcurrency)(rows, CONCURRENCY, async (row) => {
+        const externalId = Number(row.external_id);
+        const [version, skills, mcps] = await Promise.all([
+            row.head_version_id === null || row.head_version_id === undefined
+                ? Promise.resolve(null)
+                : read(client, 'get_version', { version_id: row.head_version_id }),
+            read(client, 'list_prompt_skills', { project_slug: project, prompt_external_id: externalId }),
+            read(client, 'list_prompt_mcps', { project_slug: project, prompt_external_id: externalId }),
+        ]);
+        const data = {
+            external_id: String(row.external_id),
+            name: String(row.name),
+            description: row.description ?? null,
+            version: version,
+            skills: skills.map((s) => String(s.name)),
+            mcp: mcps.map((m) => ({ instance_id: Number(m.id), enabled_tools: (m.enabled_tools ?? null) })),
+        };
+        return { kind: 'prompt', id: data.external_id, name: data.name, files: (0, render_1.renderPrompt)(data), data };
+    });
+}
+async function fetchSkills(client, project) {
+    const rows = await fetchAll(client, 'list_skills', { project_slug: project });
+    return (0, shared_1.mapWithConcurrency)(rows, CONCURRENCY, async (row) => {
+        const data = (await read(client, 'get_skill', { project_slug: project, skill_id: row.id }));
+        return { kind: 'skill', id: String(data.id), name: data.name, files: (0, render_1.renderSkill)(data), data };
+    });
+}
+async function fetchWorkflows(client, project) {
+    const rows = await fetchAll(client, 'list_workflows', { project_slug: project });
+    return (0, shared_1.mapWithConcurrency)(rows, CONCURRENCY, async (row) => {
+        const w = (await read(client, 'get_workflow', { project_slug: project, workflow_id: row.workflow_id }));
+        const active = [w.active_version, w.version].find((v) => typeof v === 'number');
+        const data = {
+            workflow_id: String(w.workflow_id), enabled: w.enabled !== false, definition: w.definition, active_version: active ?? null,
+        };
+        return { kind: 'workflow', id: data.workflow_id, name: data.workflow_id, files: (0, render_1.renderWorkflow)(data), data };
+    });
+}
+/** Rendered remote resources of the given kinds, in kind order. */
+async function fetchRemote(client, project, kinds) {
+    const out = [];
+    if (kinds.includes('prompt'))
+        out.push(...(await fetchPrompts(client, project)));
+    if (kinds.includes('skill'))
+        out.push(...(await fetchSkills(client, project)));
+    if (kinds.includes('workflow'))
+        out.push(...(await fetchWorkflows(client, project)));
+    return out;
+}