handoff-app 1.2.2-7 → 2.0.0-1

package/dist/registry/checkout/assets.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Connected-workspace asset checkout orchestration.
+ *
+ * `checkout assets [collection]` pulls published asset collections from the connected registry into
+ * this workspace: it recreates the standard workspace asset files (per-asset icon/logo bodies, the
+ * collection JSON, the icon sprite + manifest, and the downloadable ZIP/font archives) at their
+ * canonical locations. Content-addressed blobs are downloaded once per hash. Overwriting changed
+ * local files requires `--force` or an interactive confirmation. Available only from a connected
+ * workspace.
+ */
+import Handoff from '../../index';
+/**
+ * Checkout all published asset collections, or a single collection when `collection` is given.
+ * Recreates workspace asset files; prompts before overwriting changed local files unless `--force`.
+ */
+export declare const checkoutAssets: (handoff: Handoff, collection?: string) => Promise<void>;

package/dist/registry/checkout/assets.js

@@ -0,0 +1,150 @@
+"use strict";
+/**
+ * Connected-workspace asset checkout orchestration.
+ *
+ * `checkout assets [collection]` pulls published asset collections from the connected registry into
+ * this workspace: it recreates the standard workspace asset files (per-asset icon/logo bodies, the
+ * collection JSON, the icon sprite + manifest, and the downloadable ZIP/font archives) at their
+ * canonical locations. Content-addressed blobs are downloaded once per hash. Overwriting changed
+ * local files requires `--force` or an interactive confirmation. Available only from a connected
+ * workspace.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkoutAssets = void 0;
+const p = __importStar(require("@clack/prompts"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const logger_1 = require("../../utils/logger");
+const layout_1 = require("../assets/layout");
+const sets_1 = require("../assets/sets");
+const client_1 = require("../client");
+const index_1 = require("./index");
+/** Map a registry client error to an actionable checkout message. */
+const describeFetchFailure = (error, target, registryUrl) => {
+    switch (error.code) {
+        case 'not_found':
+            return `No asset collection "${target}" exists in the registry at ${registryUrl}.`;
+        case 'runtime_mode_conflict':
+            return `The registry at ${registryUrl} is not running in registry mode, so it cannot serve a checkout: ${error.message}`;
+        case 'unauthorized':
+            return `The registry rejected the access token (401). Check the configured access token matches the registry's token.`;
+        default:
+            return error.message;
+    }
+};
+/** Whether writing `bytes` to `absolutePath` would change (or create) the file. */
+const wouldChange = (absolutePath, bytes) => {
+    try {
+        if (!fs_extra_1.default.existsSync(absolutePath))
+            return true;
+        return !fs_extra_1.default.readFileSync(absolutePath).equals(bytes);
+    }
+    catch (_a) {
+        return true;
+    }
+};
+/**
+ * Checkout all published asset collections, or a single collection when `collection` is given.
+ * Recreates workspace asset files; prompts before overwriting changed local files unless `--force`.
+ */
+const checkoutAssets = (handoff, collection) => __awaiter(void 0, void 0, void 0, function* () {
+    const connection = (0, index_1.resolveConnectionOrThrow)(handoff);
+    if (collection && !(0, sets_1.isAssetCollection)(collection)) {
+        throw new index_1.CheckoutError(`Unknown asset collection "${collection}". Supported collections: ${sets_1.ASSET_COLLECTIONS.join(', ')}.`);
+    }
+    const client = (0, client_1.createRegistryClient)({ baseUrl: connection.url, accessToken: connection.accessToken });
+    let collections;
+    if (collection) {
+        collections = [collection];
+    }
+    else {
+        const summaries = yield client.listAssetCollections();
+        collections = summaries.map((summary) => summary.collection).filter(sets_1.isAssetCollection);
+        if (collections.length === 0) {
+            logger_1.Logger.info('No asset collections are published to the registry; nothing to checkout.');
+            return;
+        }
+    }
+    const payloads = [];
+    for (const col of collections) {
+        try {
+            payloads.push(yield client.checkoutAssetCollection(col));
+        }
+        catch (error) {
+            if (error instanceof client_1.RegistryClientError) {
+                throw new index_1.CheckoutError(describeFetchFailure(error, col, connection.url));
+            }
+            throw error;
+        }
+    }
+    const roots = {
+        apiPath: handoff.getAssetsApiPath(),
+        iconsZip: handoff.getIconsZipFilePath(),
+        logosZip: handoff.getLogosZipFilePath(),
+        workingPath: handoff.workingPath,
+    };
+    // Download each referenced blob once (dedup by hash), then resolve every asset to a physical write.
+    const blobCache = new Map();
+    const writes = [];
+    for (const payload of payloads) {
+        for (const asset of payload.assets) {
+            let bytes = blobCache.get(asset.contentHash);
+            if (!bytes) {
+                bytes = yield client.downloadAssetBlob(asset.contentHash);
+                blobCache.set(asset.contentHash, bytes);
+            }
+            writes.push({ absolutePath: (0, layout_1.resolveAssetPhysicalPath)(asset.path, roots), bytes });
+        }
+    }
+    const existingChanges = writes.filter((write) => fs_extra_1.default.existsSync(write.absolutePath) && wouldChange(write.absolutePath, write.bytes));
+    if (existingChanges.length > 0 && !handoff.force) {
+        const proceed = yield p.confirm({
+            message: `Checkout will overwrite ${existingChanges.length} changed local asset file(s). Continue?`,
+        });
+        if (p.isCancel(proceed) || proceed !== true) {
+            logger_1.Logger.info('Asset checkout cancelled; no files were written.');
+            return;
+        }
+    }
+    for (const write of writes) {
+        yield fs_extra_1.default.ensureDir(path_1.default.dirname(write.absolutePath));
+        yield fs_extra_1.default.writeFile(write.absolutePath, write.bytes);
+    }
+    logger_1.Logger.success(`Checked out ${collections.length} asset collection(s) (${writes.length} file(s) restored).`);
+});
+exports.checkoutAssets = checkoutAssets;

package/dist/registry/checkout/index.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Connected-workspace checkout orchestration.
+ *
+ * `checkout <component|pattern> <id>` reads a normalized registry record and its registry-safe
+ * source files from the connected registry through the shared registry client, then writes them
+ * into the local workspace in standard authoring form. The local **declaration is synthesized
+ * locally** in the configured `runtime.workspace.declarationFormat` — declarations are never read
+ * from the registry (they are workspace-only). Identity is matched by stable `id`, so a checked-out
+ * entity maps to the correct logical component/pattern and can be re-authored and re-published.
+ *
+ * Available only from a connected workspace (`runtime.mode: workspace` + a configured
+ * `registryConnection`). Overwriting existing local files is explicit: a `--force` flag or an
+ * interactive confirmation.
+ */
+import Handoff from '../../index';
+import type { TransferEntityKind } from '../transfer';
+/** A connected-workspace configuration or precondition failure surfaced to the CLI. */
+export declare class CheckoutError extends Error {
+    constructor(message: string);
+}
+/**
+ * Ensure the workspace is a connected workspace able to checkout: workspace runtime mode (a registry
+ * host has no local workspace to write into) and a resolved registry URL + access token. Throws an
+ * actionable {@link CheckoutError} naming the exact misconfiguration.
+ */
+export declare const resolveConnectionOrThrow: (handoff: Handoff) => import("../connection").ResolvedRegistryConnection;
+/**
+ * Checkout a single component or pattern from a connected workspace: precondition checks → fetch the
+ * normalized record + source files → resolve the local target → explicit-overwrite guard → write
+ * source files and synthesize the local declaration. Throws {@link CheckoutError} with actionable
+ * messaging on any precondition or fetch failure.
+ */
+export declare const checkoutEntity: (handoff: Handoff, kind: TransferEntityKind, id: string) => Promise<void>;