@seliseblocks/cli-os 0.1.4 → 0.2.0

package/dist/commands/notifier/notify.js

@@ -0,0 +1,39 @@
+import { booleanFlag, stringFlag } from "../../lib/args.js";
+import { blocksRequest } from "../../lib/api.js";
+import { confirmMutation } from "../../lib/confirm.js";
+import { compact, jsonBodyFlag, jsonFlag, listFlag } from "../../lib/json-flag.js";
+import { writeOutput } from "../../lib/output.js";
+import { requestContext } from "../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../lib/workspace.js";
+const NOTIFIER_NOTIFY_API = "/logic/v4/Notifier/Notify";
+export async function notifierNotify(argv) {
+    const { flags } = parseCommand(argv);
+    const body = {
+        ...(await jsonBodyFlag(flags)),
+        ...compact({
+            configurationName: stringFlag(flags, "configuration-name") || undefined,
+            connectionId: stringFlag(flags, "connection-id") || undefined,
+            contentAvailable: booleanFlag(flags, "content-available") || undefined,
+            denormalizedPayload: stringFlag(flags, "denormalized-payload") || undefined,
+            responseKey: stringFlag(flags, "response-key") || undefined,
+            responseValue: stringFlag(flags, "response-value") || undefined,
+            roles: listFlag(flags, "roles"),
+            saveDenormalizedPayloadAsAnObject: booleanFlag(flags, "save-denormalized-payload-as-object") || undefined,
+            subscriptionFilters: jsonFlag(flags, "subscription-filters"),
+            userIds: listFlag(flags, "user-ids")
+        })
+    };
+    if (booleanFlag(flags, "dry-run")) {
+        writeOutput({ dryRun: true, endpoint: NOTIFIER_NOTIFY_API, request: body }, flags);
+        return;
+    }
+    await confirmMutation(flags, "Send notification.");
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest(NOTIFIER_NOTIFY_API, {
+        body,
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/notifier/unread.d.ts

@@ -0,0 +1 @@
+export declare function notifierUnread(argv: string[]): Promise<void>;

package/dist/commands/notifier/unread.js

@@ -0,0 +1,25 @@
+import { optionalIntegerFlag, stringFlag } from "../../lib/args.js";
+import { blocksRequest } from "../../lib/api.js";
+import { writeOutput } from "../../lib/output.js";
+import { requestContext } from "../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../lib/workspace.js";
+// Swagger documents GetUnreadNotificationsBySubscriptionFilter as GET with a JSON
+// request body, which the Fetch spec forbids sending on a GET request. Sent as a
+// flattened query string instead, matching every other GET endpoint in this API.
+export async function notifierUnread(argv) {
+    const { flags } = parseCommand(argv);
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/logic/v4/Notifier/GetUnreadNotificationsBySubscriptionFilter", {
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey,
+        query: {
+            OrderBy: optionalIntegerFlag(flags, "order-by"),
+            "SubscriptionFilterData.ActionName": stringFlag(flags, "action-name") || undefined,
+            "SubscriptionFilterData.Context": stringFlag(flags, "context") || undefined,
+            "SubscriptionFilterData.Value": stringFlag(flags, "value") || undefined,
+            UserId: stringFlag(flags, "user-id") || undefined
+        }
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/projects/get.js

@@ -1,21 +1,23 @@
-import { blocksRequest } from "../../lib/api.js";
+import { booleanFlag } from "../../lib/args.js";
 import { writeOutput } from "../../lib/output.js";
-import { requestContext } from "../../lib/request-context.js";
+import { findProjectByTenantId, getProjectAssets } from "../../lib/project-info.js";
 import { parseCommand, selectedProject } from "../../lib/workspace.js";
 export async function getProject(argv) {
     const { args, flags } = parseCommand(argv);
     const tenantId = args[0] || await selectedProject(flags);
-    const groups = await blocksRequest("/os/v4/Project/Gets", {
-        accountAuth: true,
-        ...requestContext(flags),
-        query: { page: 0, pageSize: 100, tenantGroupId: "" }
-    });
-    for (const group of groups) {
-        const project = (group.projects ?? []).find((item) => item.tenantId === tenantId);
-        if (project) {
-            writeOutput({ group, project }, flags);
-            return;
-        }
+    const { group, project } = await findProjectByTenantId(tenantId, flags);
+    if (!booleanFlag(flags, "deployment") || !group.tenantGroupId) {
+        writeOutput({ group, project }, flags);
+        return;
     }
-    throw new Error(`Project '${tenantId}' was not found in Project/Gets.`);
+    const assets = await getProjectAssets(group.tenantGroupId, flags);
+    writeOutput({
+        deployment: {
+            environment: project.environment,
+            repos: assets.assets?.resources ?? [],
+            tenantGroupId: group.tenantGroupId
+        },
+        group,
+        project
+    }, flags);
 }

package/dist/commands/projects/list.js

@@ -1,14 +1,9 @@
-import { blocksRequest } from "../../lib/api.js";
+import { listProjectGroups } from "../../lib/project-info.js";
 import { parseCommand } from "../../lib/workspace.js";
 import { writeOutput } from "../../lib/output.js";
-import { requestContext } from "../../lib/request-context.js";
 export async function listProjects(argv = []) {
     const { flags } = parseCommand(argv);
-    const groups = await blocksRequest("/os/v4/Project/Gets", {
-        accountAuth: true,
-        ...requestContext(flags),
-        query: { page: 0, pageSize: 100, tenantGroupId: "" }
-    });
+    const groups = await listProjectGroups(flags);
     if (flags.json) {
         writeOutput(groups, flags);
         return;

package/dist/commands/release/builds/list.js

@@ -1,12 +1,15 @@
 import { stringFlag } from "../../../lib/args.js";
 import { blocksRequest } from "../../../lib/api.js";
+import { CliActionableError } from "../../../lib/errors.js";
 import { writeOutput } from "../../../lib/output.js";
+import { getProjectAssets, resolveSelectedProject } from "../../../lib/project-info.js";
+import { selectFromList } from "../../../lib/prompt.js";
 import { requestContext } from "../../../lib/request-context.js";
-import { parseCommand, selectedProject } from "../../../lib/workspace.js";
+import { parseCommand } from "../../../lib/workspace.js";
 export async function releaseBuildsList(argv) {
     const { args, flags } = parseCommand(argv);
-    const repoId = args[0] || stringFlag(flags, "repo-id", { required: true });
-    const projectKey = await selectedProject(flags);
+    const { group, tenantId: projectKey } = await resolveSelectedProject(flags);
+    const repoId = args[0] || stringFlag(flags, "repo-id") || (await resolveRepoId(group.tenantGroupId, flags));
     const result = await blocksRequest("/release/v4/api/Build/repo-details", {
         impersonatedProjectAuth: true,
         ...requestContext(flags),
@@ -15,3 +18,18 @@ export async function releaseBuildsList(argv) {
     });
     writeOutput(result, flags);
 }
+async function resolveRepoId(tenantGroupId, flags) {
+    if (!tenantGroupId) {
+        throw new CliActionableError("This project has no tenant group on record, so its linked repos can't be looked up.", "no_tenant_group", "Pass --repo-id explicitly.");
+    }
+    const response = await getProjectAssets(tenantGroupId, flags);
+    const resources = response.assets?.resources ?? [];
+    if (resources.length === 0) {
+        throw new CliActionableError("No repo linked to this project.", "repo_not_linked", "Link a repo from the Blocks portal (requires GitHub auth), then re-run this command, or pass --repo-id explicitly.");
+    }
+    const resource = resources.length === 1 ? resources[0] : resources[await selectFromList("Multiple repos are linked to this project -- choose one:", resources.map((item) => `${item.name ?? "(unnamed)"} (${item.resourceId ?? "?"})`))];
+    if (!resource.resourceId) {
+        throw new Error("The selected repo asset is missing a resourceId.");
+    }
+    return resource.resourceId;
+}

package/dist/commands/release/deploy.js

@@ -1,46 +1,137 @@
-import { booleanFlag, stringFlag } from "../../lib/args.js";
+import { booleanFlag, integerFlag, stringFlag } from "../../lib/args.js";
 import { blocksRequest } from "../../lib/api.js";
 import { confirmMutation } from "../../lib/confirm.js";
+import { CliActionableError } from "../../lib/errors.js";
 import { writeOutput } from "../../lib/output.js";
+import { getProjectAssets, resolveSelectedProject } from "../../lib/project-info.js";
 import { requestContext } from "../../lib/request-context.js";
-import { parseCommand, pathsFromWorkspace, readWorkspaceConfig, selectedProject } from "../../lib/workspace.js";
-import { readFile } from "node:fs/promises";
+import { parseCommand } from "../../lib/workspace.js";
+const DEFAULT_POLL_INTERVAL_SECONDS = 10;
+const DEFAULT_WAIT_TIMEOUT_SECONDS = 900;
+const TERMINAL_STATUS_PATTERN = /succeed|success|complet|fail|error|cancel|abort|done/i;
 export async function releaseDeploy(argv) {
     const { flags } = parseCommand(argv);
-    const config = await readReleaseConfig();
-    const repoId = stringFlag(flags, "repo-id", { defaultValue: stringValue(config.repoId) });
-    if (!repoId)
-        throw new Error("Missing --repo-id or blocks/release/deploy.json repoId.");
-    const body = {
-        ...config,
-        repoId
-    };
-    if (booleanFlag(flags, "dry-run")) {
-        writeOutput({ dryRun: true, endpoint: "/release/v4/api/Build/manual", request: body }, flags);
+    const domain = stringFlag(flags, "domain");
+    const dryRun = booleanFlag(flags, "dry-run");
+    const { project, group, tenantId: projectKey } = await resolveSelectedProject(flags);
+    const environment = project.environment;
+    const tenantGroupId = group.tenantGroupId;
+    if (!environment || !tenantGroupId) {
+        throw new Error(`Project '${projectKey}' was not found in Project/Gets.`);
+    }
+    const repoId = await resolveRepoId(tenantGroupId, environment, flags);
+    const { branch, repoUrl } = await resolveRepoBranch(repoId, projectKey, flags);
+    if (branch.toLowerCase() !== environment.toLowerCase()) {
+        throw new CliActionableError(`Connected repo's branch '${branch}' does not match this project's environment '${environment}'.`, "branch_environment_mismatch", `Point the linked repo at a branch named '${environment}', or relink the correct branch from the Blocks portal.`);
+    }
+    if (dryRun) {
+        writeOutput({
+            branch,
+            domain: domain || undefined,
+            dryRun: true,
+            environment,
+            projectKey,
+            repoId
+        }, flags);
         return;
     }
-    await confirmMutation(flags, `Trigger configured release build for repo '${repoId}'.`);
-    const projectKey = await selectedProject(flags);
+    await confirmMutation(flags, `Deploy '${environment}' (repo ${repoId}, branch ${branch}).`);
+    if (domain) {
+        await blocksRequest("/release/v4/api/Build/repo-update", {
+            body: {
+                projectEnv: environment,
+                repoWithDomains: [{ customDeploymentDomain: domain, repoId, repoUrl }]
+            },
+            impersonatedProjectAuth: true,
+            projectTenantId: projectKey,
+            ...requestContext(flags)
+        });
+    }
     const result = await blocksRequest("/release/v4/api/Build/manual", {
+        body: { repoId },
         impersonatedProjectAuth: true,
-        ...requestContext(flags),
-        body,
-        projectTenantId: projectKey
+        projectTenantId: projectKey,
+        ...requestContext(flags)
     });
-    writeOutput(result, flags);
+    if (!booleanFlag(flags, "wait")) {
+        writeOutput(result, flags);
+        return;
+    }
+    const buildId = firstString(result, ["buildId", "itemId", "id", "buildID"]);
+    if (!buildId) {
+        console.warn(`Warning: could not find a buildId in the deploy response to wait on. Response: ${JSON.stringify(result)}`);
+        writeOutput(result, flags);
+        return;
+    }
+    const finalStatus = await waitForBuild(buildId, flags);
+    writeOutput({ build: finalStatus, buildId, deploy: result }, flags);
+}
+async function waitForBuild(buildId, flags) {
+    const pollIntervalMs = integerFlag(flags, "poll-interval", DEFAULT_POLL_INTERVAL_SECONDS) * 1000;
+    const timeoutMs = integerFlag(flags, "timeout", DEFAULT_WAIT_TIMEOUT_SECONDS) * 1000;
+    const deadline = Date.now() + timeoutMs;
+    console.log(`Waiting for build '${buildId}' (polling every ${pollIntervalMs / 1000}s, timeout ${timeoutMs / 1000}s)...`);
+    while (true) {
+        const status = await blocksRequest("/release/v4/api/Build", {
+            impersonatedProjectAuth: true,
+            query: { buildId },
+            ...requestContext(flags)
+        });
+        console.log(JSON.stringify(status, null, 2));
+        if (containsTerminalStatus(status))
+            return status;
+        if (Date.now() >= deadline) {
+            throw new CliActionableError(`Timed out after ${timeoutMs / 1000}s waiting for build '${buildId}' to reach a terminal status.`, "build_wait_timeout", `Check manually with 'blocks release status ${buildId}'.`);
+        }
+        await delay(pollIntervalMs);
+    }
+}
+function containsTerminalStatus(value, depth = 0) {
+    if (depth > 3 || value === null || value === undefined)
+        return false;
+    if (typeof value === "string")
+        return TERMINAL_STATUS_PATTERN.test(value);
+    if (Array.isArray(value))
+        return value.some((item) => containsTerminalStatus(item, depth + 1));
+    if (typeof value === "object")
+        return Object.values(value).some((item) => containsTerminalStatus(item, depth + 1));
+    return false;
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function firstString(record, keys) {
+    for (const key of keys) {
+        const value = record[key];
+        if (typeof value === "string" && value)
+            return value;
+    }
+    return undefined;
 }
-async function readReleaseConfig() {
-    const workspace = await readWorkspaceConfig();
-    const { releaseConfig } = pathsFromWorkspace(workspace);
-    try {
-        return JSON.parse(await readFile(releaseConfig, "utf8"));
+async function resolveRepoId(tenantGroupId, environment, flags) {
+    const response = await getProjectAssets(tenantGroupId, flags);
+    const resources = response.assets?.resources ?? [];
+    if (resources.length === 0) {
+        throw new CliActionableError("No repo linked to this project.", "repo_not_linked", "Link a repo from the Blocks portal (requires GitHub auth), then re-run this command.");
     }
-    catch (error) {
-        if (error.code === "ENOENT")
-            return {};
-        throw error;
+    const matched = resources.length === 1
+        ? resources[0]
+        : resources.find((resource) => resource.name?.toLowerCase() === environment.toLowerCase());
+    if (!matched?.resourceId) {
+        throw new CliActionableError(`Multiple repos are linked to this project and none is named for environment '${environment}'.`, "repo_ambiguous", "Check the repo links for this project from the Blocks portal.");
     }
+    return matched.resourceId;
 }
-function stringValue(value) {
-    return typeof value === "string" ? value : undefined;
+async function resolveRepoBranch(repoId, projectKey, flags) {
+    const result = await blocksRequest("/release/v4/api/Build/repo-details", {
+        impersonatedProjectAuth: true,
+        projectTenantId: projectKey,
+        query: { RepoId: repoId },
+        ...requestContext(flags)
+    });
+    const repo = result.data?.repo;
+    if (!repo?.branch) {
+        throw new CliActionableError(`Repo '${repoId}' from this project's linked asset was not found in blocks-release.`, "repo_not_found", "Check the repo link for this project from the Blocks portal.");
+    }
+    return { branch: repo.branch, repoUrl: repo.repoUrl ?? "" };
 }

package/dist/commands/sdk/client.d.ts

@@ -0,0 +1 @@
+export declare function sdkClient(argv: string[]): Promise<void>;

package/dist/commands/sdk/client.js

@@ -0,0 +1,99 @@
+import { blocksRequest } from "../../lib/api.js";
+import { stringFlag } from "../../lib/args.js";
+import { defaults } from "../../lib/config.js";
+import { findProjectByTenantId } from "../../lib/project-info.js";
+import { writeOutput } from "../../lib/output.js";
+import { requestContext } from "../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../lib/workspace.js";
+// Read-only: "I want to use the Blocks SDK in my app -- show me the client."
+// Resolves this project's createBlocksClient() config and prints it, same
+// values 'new web' scaffolds with. Never writes a file and never mutates
+// anything -- if you want the SDK wired into a new app, use 'new web'.
+export async function sdkClient(argv) {
+    const { flags } = parseCommand(argv);
+    const tenantId = stringFlag(flags, "x-blocks-key") || (await selectedProject(flags));
+    const apiUrl = stringFlag(flags, "blocks-api-url", { defaultValue: defaults().apiUrl });
+    const oidcUrl = stringFlag(flags, "oidc-url", { defaultValue: defaults().oidcUrl });
+    let appDomain = stringFlag(flags, "app-domain");
+    let oidcClientId = stringFlag(flags, "client-id");
+    const notes = [];
+    if (!appDomain || !oidcClientId) {
+        const { project } = await findProjectByTenantId(tenantId, flags);
+        if (!appDomain) {
+            const domains = (project.applications ?? [])
+                .map((application) => application.domain)
+                .filter((domain) => Boolean(domain));
+            if (domains.length === 1) {
+                appDomain = domains[0];
+            }
+            else if (domains.length > 1) {
+                notes.push(`Multiple domains registered for this project (${domains.join(", ")}) -- pass --app-domain to pick one.`);
+            }
+            else {
+                notes.push("This project has no domains registered in Blocks -- pass --app-domain explicitly.");
+            }
+        }
+        if (!oidcClientId) {
+            const clients = await listOidcClients(tenantId, flags);
+            if (clients.length === 1) {
+                oidcClientId = clients[0].id;
+            }
+            else if (clients.length > 1) {
+                notes.push(`Multiple OIDC clients found (${clients.map((client) => `${client.label} [${client.id}]`).join(", ")}) -- pass --client-id to pick one.`);
+            }
+            else {
+                notes.push("No OIDC client registered for this project -- create one ('auth:oidc-clients:save') and pass --client-id.");
+            }
+        }
+    }
+    if (flags.json) {
+        writeOutput({ apiUrl, appDomain: appDomain || undefined, notes, oidcClientId: oidcClientId || undefined, oidcUrl, xBlocksKey: tenantId }, flags);
+        return;
+    }
+    console.log("import { createBlocksClient } from \"@seliseblocks/client\";");
+    console.log("");
+    console.log("export const blocksClient = createBlocksClient({");
+    console.log(`  apiUrl: "${apiUrl}",`);
+    if (appDomain)
+        console.log(`  appDomain: "${appDomain}",`);
+    console.log("  oidc: {");
+    console.log(`    clientId: "${oidcClientId || "<register a public OIDC client, see auth:oidc-clients:save>"}",`);
+    console.log("    scope: \"openid profile\",");
+    console.log(`    url: "${oidcUrl}"`);
+    console.log("  },");
+    console.log(`  xBlocksKey: "${tenantId}"`);
+    console.log("});");
+    for (const note of notes)
+        console.log(`\n${note}`);
+}
+async function listOidcClients(tenantId, flags) {
+    const raw = await blocksRequest("/iam/v4/oidc-clients", {
+        impersonatedProjectAuth: true,
+        projectTenantId: tenantId,
+        ...requestContext(flags)
+    });
+    const clients = [];
+    for (const item of normalizeList(raw)) {
+        if (typeof item !== "object" || item === null)
+            continue;
+        const record = item;
+        const id = record.itemId ?? record.clientId ?? record.id;
+        if (typeof id !== "string" || !id)
+            continue;
+        const label = typeof record.clientDisplayName === "string" && record.clientDisplayName ? record.clientDisplayName : id;
+        clients.push({ id, label });
+    }
+    return clients;
+}
+function normalizeList(raw) {
+    if (Array.isArray(raw))
+        return raw;
+    if (raw && typeof raw === "object") {
+        for (const key of ["data", "items", "results"]) {
+            const value = raw[key];
+            if (Array.isArray(value))
+                return value;
+        }
+    }
+    return [];
+}

package/dist/commands/secrets/get.d.ts

@@ -0,0 +1 @@
+export declare function secretsGet(argv: string[]): Promise<void>;

package/dist/commands/secrets/get.js

@@ -0,0 +1,21 @@
+import { integerFlag, stringFlag } from "../../lib/args.js";
+import { blocksRequest } from "../../lib/api.js";
+import { writeOutput } from "../../lib/output.js";
+import { requestContext } from "../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../lib/workspace.js";
+export async function secretsGet(argv) {
+    const { args, flags } = parseCommand(argv);
+    const secretKey = args[0] || stringFlag(flags, "secret-key", { required: true });
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/os/v4/Secrets/Gets", {
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey,
+        query: {
+            PageNumber: integerFlag(flags, "page-number", 0),
+            PageSize: integerFlag(flags, "page-size", 10),
+            secretKey
+        }
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/secrets/save.d.ts

@@ -0,0 +1 @@
+export declare function secretsSave(argv: string[]): Promise<void>;

package/dist/commands/secrets/save.js

@@ -0,0 +1,51 @@
+import { booleanFlag, stringFlag } from "../../lib/args.js";
+import { blocksRequest } from "../../lib/api.js";
+import { confirmMutation } from "../../lib/confirm.js";
+import { compact, jsonBodyFlag, jsonFlag } from "../../lib/json-flag.js";
+import { writeOutput } from "../../lib/output.js";
+import { requestContext } from "../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../lib/workspace.js";
+const SECRETS_SAVE_API = "/os/v4/Secrets/Save";
+export async function secretsSave(argv) {
+    const { flags } = parseCommand(argv);
+    const body = {
+        ...(await jsonBodyFlag(flags)),
+        ...compact({
+            itemId: stringFlag(flags, "item-id") || undefined,
+            keyValuePairs: keyValuePairsFlag(flags),
+            secretKey: stringFlag(flags, "secret-key") || undefined
+        })
+    };
+    if (booleanFlag(flags, "dry-run")) {
+        writeOutput({ dryRun: true, endpoint: SECRETS_SAVE_API, request: redactSecret(body) }, flags);
+        return;
+    }
+    await confirmMutation(flags, `Save secret '${body.secretKey ?? ""}'.`);
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest(SECRETS_SAVE_API, {
+        body,
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey
+    });
+    writeOutput(result, flags);
+}
+function keyValuePairsFlag(flags) {
+    const parsed = jsonFlag(flags, "key-value-pairs");
+    if (parsed === undefined)
+        return undefined;
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("--key-value-pairs must be a JSON object, e.g. '{\"isEnable\":\"true\"}'");
+    }
+    return parsed;
+}
+function redactSecret(body) {
+    const pairs = body.keyValuePairs;
+    if (!pairs || typeof pairs !== "object")
+        return body;
+    const redacted = {};
+    for (const [key, value] of Object.entries(pairs)) {
+        redacted[key] = /(secret|password|key$)/i.test(key) ? "***" : value;
+    }
+    return { ...body, keyValuePairs: redacted };
+}

package/dist/commands/skill/add.d.ts

@@ -0,0 +1 @@
+export declare function skillAdd(argv: string[]): Promise<void>;

package/dist/commands/skill/add.js

@@ -0,0 +1,19 @@
+import { cp } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { stringFlag } from "../../lib/args.js";
+import { readSkill } from "../../lib/skills.js";
+import { parseCommand } from "../../lib/workspace.js";
+export async function skillAdd(argv) {
+    const { args, flags } = parseCommand(argv);
+    const name = args[0];
+    if (!name)
+        throw new Error("Missing skill name. Run 'blocks skill list' to see available skills.");
+    const skill = await readSkill(name);
+    const sourceDir = dirname(skill.path);
+    const targetDir = stringFlag(flags, "dir", { defaultValue: "blocks-skills" });
+    const targetPath = join(process.cwd(), targetDir, name);
+    // Copy the whole skill directory, not just SKILL.md -- some skills also ship
+    // supporting files (e.g. flows/*.md) that SKILL.md links to.
+    await cp(sourceDir, targetPath, { recursive: true });
+    console.log(`Added ${targetPath}`);
+}

package/dist/commands/skill/list.d.ts

@@ -0,0 +1 @@
+export declare function skillList(argv: string[]): Promise<void>;

package/dist/commands/skill/list.js

@@ -0,0 +1,15 @@
+import { listSkills, SKILLS_REPO_URL } from "../../lib/skills.js";
+import { writeOutput } from "../../lib/output.js";
+import { parseCommand } from "../../lib/workspace.js";
+export async function skillList(argv) {
+    const { flags } = parseCommand(argv);
+    const skills = await listSkills();
+    if (flags.json) {
+        writeOutput(skills, flags);
+        return;
+    }
+    for (const skill of skills) {
+        console.log(`${skill.name}  ${skill.description}`);
+    }
+    console.log(`\nFull catalog (may be ahead of this bundled list): ${SKILLS_REPO_URL}`);
+}

package/dist/commands/skill/show.d.ts

@@ -0,0 +1 @@
+export declare function skillShow(argv: string[]): Promise<void>;

package/dist/commands/skill/show.js

@@ -0,0 +1,15 @@
+import { readSkill } from "../../lib/skills.js";
+import { writeOutput } from "../../lib/output.js";
+import { parseCommand } from "../../lib/workspace.js";
+export async function skillShow(argv) {
+    const { args, flags } = parseCommand(argv);
+    const name = args[0];
+    if (!name)
+        throw new Error("Missing skill name. Run 'blocks skill list' to see available skills.");
+    const skill = await readSkill(name);
+    if (flags.json) {
+        writeOutput(skill, flags);
+        return;
+    }
+    console.log(skill.content);
+}

package/dist/commands/storage/config/delete.d.ts

@@ -0,0 +1 @@
+export declare function storageConfigDelete(argv: string[]): Promise<void>;

package/dist/commands/storage/config/delete.js

@@ -0,0 +1,24 @@
+import { booleanFlag, stringFlag } from "../../../lib/args.js";
+import { blocksRequest } from "../../../lib/api.js";
+import { confirmMutation } from "../../../lib/confirm.js";
+import { writeOutput } from "../../../lib/output.js";
+import { requestContext } from "../../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../../lib/workspace.js";
+export async function storageConfigDelete(argv) {
+    const { args, flags } = parseCommand(argv);
+    const name = args[0] || stringFlag(flags, "name", { required: true });
+    if (booleanFlag(flags, "dry-run")) {
+        writeOutput({ dryRun: true, endpoint: "/os/v4/Storage/Delete", query: { ConfigurationName: name } }, flags);
+        return;
+    }
+    await confirmMutation(flags, `Delete storage configuration '${name}'.`);
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/os/v4/Storage/Delete", {
+        impersonatedProjectAuth: true,
+        method: "DELETE",
+        ...requestContext(flags),
+        projectTenantId: projectKey,
+        query: { ConfigurationName: name }
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/storage/config/get.d.ts

@@ -0,0 +1 @@
+export declare function storageConfigGet(argv: string[]): Promise<void>;

package/dist/commands/storage/config/get.js

@@ -0,0 +1,17 @@
+import { stringFlag } from "../../../lib/args.js";
+import { blocksRequest } from "../../../lib/api.js";
+import { writeOutput } from "../../../lib/output.js";
+import { requestContext } from "../../../lib/request-context.js";
+import { parseCommand, selectedProject } from "../../../lib/workspace.js";
+export async function storageConfigGet(argv) {
+    const { args, flags } = parseCommand(argv);
+    const name = args[0] || stringFlag(flags, "name", { required: true });
+    const projectKey = await selectedProject(flags);
+    const result = await blocksRequest("/os/v4/Storage/Get", {
+        impersonatedProjectAuth: true,
+        ...requestContext(flags),
+        projectTenantId: projectKey,
+        query: { ConfigurationName: name }
+    });
+    writeOutput(result, flags);
+}

package/dist/commands/storage/config/list.d.ts

@@ -0,0 +1 @@
+export declare function storageConfigList(argv: string[]): Promise<void>;