@decohere/scaffold 0.0.1-dev.18 → 0.0.1-dev.20261105.54

package/commonjs/src/webapi/postman/local-view.js

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get buildEnvironmentYaml () {
+        return buildEnvironmentYaml;
+    },
+    get buildLocalViewFilesFromCollection () {
+        return buildLocalViewFilesFromCollection;
+    }
+});
+const _nodecrypto = require("node:crypto");
+const _openapitopostman = require("./openapi-to-postman.js");
+function yamlQuote(value) {
+    if (/[:#{}[\],&*?|<>=!%@`]/.test(value) || value.includes("\n") || value === "") {
+        return JSON.stringify(value);
+    }
+    return value;
+}
+function buildEnvironmentYaml(name, auth, options) {
+    const values = [
+        {
+            key: "baseUrl",
+            value: "http://localhost:3000"
+        }
+    ];
+    if (auth?.auth0Domain) {
+        values.push({
+            key: "auth0Domain",
+            value: auth.auth0Domain
+        }, {
+            key: "auth0Audience",
+            value: auth.auth0Audience ?? ""
+        }, {
+            key: "auth0ClientId",
+            value: auth.auth0ClientId ?? ""
+        }, {
+            key: "authUrl",
+            value: `https://${auth.auth0Domain}/authorize?audience=${auth.auth0Audience ?? ""}`
+        }, {
+            key: "accessTokenUrl",
+            value: `https://${auth.auth0Domain}/oauth/token`
+        }, {
+            key: "callbackUrl",
+            value: options.callbacks[0]
+        }, {
+            key: "scope",
+            value: options.scopes
+        });
+    }
+    const lines = [
+        `name: ${yamlQuote(name)}`,
+        "values:"
+    ];
+    for (const v of values){
+        lines.push(`  - key: ${v.key}`);
+        lines.push(`    value: ${yamlQuote(v.value)}`);
+        lines.push("    enabled: true");
+    }
+    return `${lines.join("\n")}\n`;
+}
+function buildLocalViewFilesFromCollection(collection, projectName, auth, options) {
+    const collectionDir = `postman/collections/${projectName} WebAPI`;
+    const files = [];
+    const authBlock = auth?.auth0Domain ? [
+        "auth:",
+        `  - id: ${(0, _nodecrypto.randomUUID)()}`,
+        "    type: oauth2",
+        "    name: OAuth 2.0",
+        "    credentials:",
+        "      addTokenTo: header",
+        "      grant_type: authorization_code_with_pkce",
+        `      authUrl: https://${auth.auth0Domain}/authorize?audience=${auth.auth0Audience ?? ""}`,
+        `      accessTokenUrl: https://${auth.auth0Domain}/oauth/token`,
+        `      clientId: ${yamlQuote(auth.auth0ClientId ?? "")}`,
+        `      scope: ${yamlQuote(options.scopes)}`,
+        `      redirect_uri: ${options.callbacks[0]}`,
+        "      useBrowser: true",
+        "      challengeAlgorithm: S256",
+        "      client_authentication: body",
+        '      clientSecret: ""',
+        `      tokenName: ${yamlQuote(`${projectName} Access Token`)}`,
+        ""
+    ].join("\n") : "";
+    files.push({
+        filePath: `${collectionDir}/.resources/definition.yaml`,
+        content: [
+            "$kind: collection",
+            `name: ${yamlQuote(`${projectName} WebAPI`)}`,
+            "schemaVersion: '3.0'",
+            "description: >-",
+            "  Open this project root in Postman Local View (Files → Open folder).",
+            "  Select the Local environment, then Authorization → Get New Access Token (PKCE).",
+            "  Route requests are generated from OpenAPI; Auth0 overlay is hand-authored.",
+            authBlock
+        ].filter((l)=>l !== undefined).join("\n").replace(/\n+$/, "\n")
+    });
+    let folderOrder = 1000;
+    for (const folder of collection.item ?? []){
+        if (folder.item == null) {
+            continue;
+        }
+        const folderName = folder.name ?? "Requests";
+        files.push({
+            filePath: `${collectionDir}/${folderName}/.resources/definition.yaml`,
+            content: [
+                "$kind: folder",
+                `name: ${yamlQuote(folderName)}`,
+                `order: ${folderOrder}`,
+                ""
+            ].join("\n")
+        });
+        folderOrder += 1000;
+        let requestOrder = 1000;
+        for (const child of folder.item){
+            const yaml = requestToLocalViewYaml(child, requestOrder);
+            if (yaml == null) {
+                continue;
+            }
+            const fileName = `${sanitizeFileName(child.name ?? "Request")}.request.yaml`;
+            files.push({
+                filePath: `${collectionDir}/${folderName}/${fileName}`,
+                content: yaml
+            });
+            requestOrder += 1000;
+        }
+    }
+    return files;
+}
+function requestToLocalViewYaml(item, order) {
+    const request = item.request;
+    if (request == null) {
+        return null;
+    }
+    const method = (request.method ?? "GET").toUpperCase();
+    const url = requestUrlForLocalView(request);
+    const lines = [
+        "$kind: http-request",
+        `name: ${yamlQuote(item.name ?? method)}`,
+        `method: ${method}`,
+        `url: ${yamlQuote(url)}`
+    ];
+    if (request.auth?.type === "noauth") {
+        lines.push("auth:", "  type: noauth");
+    }
+    const contentType = request.header?.find((h)=>h.key.toLowerCase() === "content-type")?.value;
+    const rawBody = request.body?.raw?.trim();
+    if (rawBody) {
+        lines.push("headers:");
+        lines.push(`  Content-Type: ${contentType ?? "application/json"}`);
+        lines.push("body:");
+        lines.push("  type: json");
+        lines.push("  content: |-");
+        for (const bodyLine of rawBody.split("\n")){
+            lines.push(`    ${bodyLine}`);
+        }
+    }
+    lines.push(`order: ${order}`, "");
+    return lines.join("\n");
+}
+function requestUrlForLocalView(request) {
+    const url = request.url;
+    if (typeof url === "string") {
+        return (0, _openapitopostman.openApiPathParamsToColon)(url);
+    }
+    if (url?.raw) {
+        return (0, _openapitopostman.openApiPathParamsToColon)(url.raw);
+    }
+    const host = url?.host?.[0] ?? "{{baseUrl}}";
+    const path = (url?.path ?? []).map((segment)=>(0, _openapitopostman.openApiPathParamsToColon)(String(segment))).join("/");
+    return path ? `${host}/${path}` : host;
+}
+function sanitizeFileName(name) {
+    return name.replace(/[^\w\s()-]+/g, "").trim() || "Request";
+}

package/commonjs/src/webapi/postman/openapi-to-postman.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get applyPostmanAuthOverlay () {
+        return applyPostmanAuthOverlay;
+    },
+    get openApiPathParamsToColon () {
+        return openApiPathParamsToColon;
+    },
+    get openApiToPostmanCollection () {
+        return openApiToPostmanCollection;
+    }
+});
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+async function convertAsync(data, options) {
+    // Loaded here, not at the top: the converter pulls in about 700 modules (lodash, faker, ajv,
+    // …), which every scaffolder run paid for even with `--postman none`.
+    const { default: converter } = await Promise.resolve().then(()=>/*#__PURE__*/ _interop_require_wildcard(require("openapi-to-postmanv2")));
+    return new Promise((resolve, reject)=>{
+        converter.convert({
+            type: "json",
+            data
+        }, options, (err, result)=>{
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(result);
+        });
+    });
+}
+async function openApiToPostmanCollection(document) {
+    const result = await convertAsync(document, {
+        folderStrategy: "Tags",
+        requestNameSource: "Fallback",
+        includeAuthInfoInExample: false
+    });
+    if (!result.result || result.output?.[0]?.data == null) {
+        throw new Error(result.reason ?? "openapi-to-postmanv2 conversion failed");
+    }
+    return result.output[0].data;
+}
+function applyPostmanAuthOverlay(collection, projectName, auth, options) {
+    const next = {
+        ...collection,
+        info: {
+            ...collection.info,
+            name: `${projectName} WebAPI`,
+            description: options.description,
+            schema: collection.info.schema ?? "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
+        }
+    };
+    if (auth?.auth0Domain) {
+        next.auth = {
+            type: "oauth2",
+            oauth2: [
+                {
+                    key: "grant_type",
+                    value: "authorization_code_with_pkce",
+                    type: "string"
+                },
+                {
+                    key: "authUrl",
+                    value: "https://{{auth0Domain}}/authorize?audience={{auth0Audience}}",
+                    type: "string"
+                },
+                {
+                    key: "accessTokenUrl",
+                    value: "https://{{auth0Domain}}/oauth/token",
+                    type: "string"
+                },
+                {
+                    key: "clientId",
+                    value: "{{auth0ClientId}}",
+                    type: "string"
+                },
+                {
+                    key: "scope",
+                    value: options.scopes,
+                    type: "string"
+                },
+                {
+                    key: "redirect_uri",
+                    value: options.callbacks[0],
+                    type: "string"
+                },
+                {
+                    key: "useBrowser",
+                    value: "true",
+                    type: "boolean"
+                },
+                {
+                    key: "addTokenTo",
+                    value: "header",
+                    type: "string"
+                },
+                {
+                    key: "challengeAlgorithm",
+                    value: "S256",
+                    type: "string"
+                },
+                {
+                    key: "client_authentication",
+                    value: "body",
+                    type: "string"
+                },
+                {
+                    key: "clientSecret",
+                    value: "",
+                    type: "string"
+                },
+                {
+                    key: "tokenName",
+                    value: `${projectName} Access Token`,
+                    type: "string"
+                }
+            ]
+        };
+    }
+    next.item = rewriteCollectionItems(collection.item ?? [], {
+        markListAnonymous: true
+    });
+    return next;
+}
+function rewriteCollectionItems(items, opts) {
+    return items.map((item)=>{
+        if (item.item != null) {
+            return {
+                ...item,
+                item: rewriteCollectionItems(item.item, opts)
+            };
+        }
+        const request = item.request;
+        if (request == null) {
+            return item;
+        }
+        const method = (request.method ?? "GET").toUpperCase();
+        const rawUrl = requestUrlRaw(request);
+        const nextRequest = {
+            ...request,
+            url: toPostmanUrl(rawUrl)
+        };
+        // List Hello stays anonymous (matches scaffold AllowAnonymous on GET /hello).
+        if (opts.markListAnonymous && method === "GET" && normalizePath(rawUrl) === "/hello" && !rawUrl.includes("/:")) {
+            nextRequest.auth = {
+                type: "noauth"
+            };
+        }
+        return {
+            ...item,
+            request: nextRequest
+        };
+    });
+}
+function requestUrlRaw(request) {
+    const url = request.url;
+    if (typeof url === "string") {
+        return url;
+    }
+    if (url?.raw) {
+        return url.raw;
+    }
+    const host = url?.host?.[0] ?? "{{baseUrl}}";
+    const path = (url?.path ?? []).join("/");
+    return path ? `${host}/${path}` : host;
+}
+function openApiPathParamsToColon(url) {
+    return url.replace(/(?<!\{)\{([A-Za-z_][\w]*)\}(?!\})/g, ":$1");
+}
+function normalizePath(rawUrl) {
+    const withoutBase = rawUrl.replace(/\{\{baseUrl\}\}/g, "").split("?")[0] ?? "";
+    const withSlash = withoutBase.startsWith("/") ? withoutBase : `/${withoutBase}`;
+    return openApiPathParamsToColon(withSlash);
+}
+/** Prefer Postman template URL shape used by existing Local View / API uploads. */ function toPostmanUrl(rawUrl) {
+    let pathPart = rawUrl.replace(/\{\{baseUrl\}\}/g, "");
+    if (!pathPart.startsWith("/")) {
+        pathPart = `/${pathPart}`;
+    }
+    // openapi-to-postman uses {id}; Local View / prior collections use :id
+    pathPart = openApiPathParamsToColon(pathPart);
+    const segments = pathPart.split("/").filter(Boolean);
+    return {
+        raw: `{{baseUrl}}${pathPart}`,
+        host: [
+            "{{baseUrl}}"
+        ],
+        path: segments
+    };
+}

package/commonjs/src/webapi/workspace-readme.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get renderWorkspaceReadme () {
+        return renderWorkspaceReadme;
+    },
+    get resolveWorkspaceReadmeInput () {
+        return resolveWorkspaceReadmeInput;
+    },
+    get writeWorkspaceReadme () {
+        return writeWorkspaceReadme;
+    }
+});
+const _nodefs = require("node:fs");
+const _nodepath = require("node:path");
+const _const = require("../models/const.js");
+const _apiname = require("./api-name.js");
+function renderWorkspaceReadme(input) {
+    const { projectName, apiNames, hasPostgres, hasAuth0, hasPostman } = input;
+    const apis = apiNames.length > 0 ? apiNames : [
+        "api"
+    ];
+    const lines = [
+        `# ${projectName}`,
+        "",
+        "Decohere web API workspace. Scaffolded with [`@decohere/create`](https://www.npmjs.com/package/@decohere/create).",
+        "",
+        "## Get started",
+        "",
+        "1. Open this folder in VS Code / Cursor.",
+        "2. **Reopen in Container** (or rebuild the Dev Container).",
+        "   Host `initialize.sh` and container `post-start.sh` ask y/N (TTY only) before npm auth or codebase RAG MCP.",
+        "   Skip or decline; missing TTY skips. RAG credentials land in `.cursor/` (gitignored).",
+        "3. Install dependencies if needed:",
+        "",
+        "```bash",
+        "pnpm install",
+        "```",
+        "",
+        "## Develop",
+        "",
+        "```bash",
+        "pnpm dev              # Flux HMR (first API)",
+        "pnpm start            # run the compiled first API",
+        "pnpm run build        # forge release build",
+        "pnpm run package      # release build + .package/ for each API (what Docker copies)"
+    ];
+    for (const name of apis){
+        lines.push(`pnpm run dev:${name}     # HMR for ${name}`);
+        lines.push(`pnpm run start:${name}   # production entry for ${name}`);
+    }
+    lines.push("```", "");
+    lines.push("## Logging", "", "In development, Scribe uses pino-pretty and rolling files under `logs/` (gitignored).", "When `NODE_ENV=production`, the process writes structured JSON to stdout and does not rotate files.", "Ship and retain those streams outside the app (platform logs, a sidecar, or a log agent) so shipping can change without rebuilding.", "", "Override roll path and rotation without changing app code:", "`SCRIBE_LOG_FILE`, `SCRIBE_LOG_SIZE`, `SCRIBE_LOG_FREQUENCY`, `SCRIBE_LOG_KEEP`.", "", 'Opt into in-process pretty or roll in production only with `{ when: "always" }` on `scribe.withPinoPretty` / `scribe.withPinoRoll`.', "");
+    if (hasPostgres) {
+        lines.push("## Database", "", "Postgres runs via Dev Container Compose:", "", "```bash", "pnpm db:up", "pnpm db:down", "pnpm db:reset", "```", "");
+    }
+    lines.push("## Deploy", "", "Each API has its own `projects/<name>/Dockerfile`. It copies `.package/`, which `forge package`", "writes before Docker runs: the API's compiled code, the workspace libraries it imports, and", "a plain `node_modules` of the third-party packages it uses (no symlinks). The image build", "installs nothing and needs no npm token.", "", "```bash", "pnpm run package         # release build, then .package/ in every API", `docker build -t ${projectName} projects/api`, "```", "", "One API: `pnpm run package:<name>`, then `docker build projects/<name>`.", "A host that builds from a git clone does not have `.package/`; build and push the image", "from CI instead (`forge docker` after `pnpm run package`).", "");
+    lines.push("## Add another API", "", "```bash", "decohere add api <name>", "```", "", "Example: `decohere add api billing`", "");
+    if (hasAuth0) {
+        lines.push("## Auth0", "", "JWT auth is wired from `.env` (`AUTH0_ISSUER_BASE_URL`, `AUTH0_AUDIENCE`).", 'After you add a controller, `@Authorize("read", "Invoice")` becomes the Auth0 permission `read:Invoice`.', "Sync the Auth0 API, admin grants, and Postman token scopes without re-scaffolding:", "", "```bash", "npx @decohere/create auth0 login      # once / when the CLI token expires", "npx @decohere/create auth0 configure  # after new @Authorize decorators", "```", "");
+    }
+    if (hasPostman) {
+        lines.push("## Postman", "", "Open this **project root** in Postman Local View (Files → Open folder), not the `postman/` subfolder.", "Select the Local environment, then Authorization → Get New Access Token when Auth0 is enabled.", "");
+    }
+    lines.push("## More", "", "- Package docs: https://www.npmjs.com/package/@decohere/create", "- After `decohere add api`, this README is refreshed so scripts and APIs stay accurate.", "");
+    return `${lines.join("\n")}`;
+}
+function resolveWorkspaceReadmeInput(workspace, options) {
+    const newNames = workspace.getProjects().map((project)=>(0, _apiname.apiNameFromProjectDir)(project.dir));
+    const apiNames = options.add ? mergeApiNames((0, _apiname.listExistingApiNames)(workspace.targetDir), newNames) : newNames;
+    const pkg = workspace.getModel(_const.WELL_KNOWN_FILES.PACKAGE_JSON);
+    const env = workspace.getModel(_const.WELL_KNOWN_FILES.ENV_FILE);
+    const hasPostgres = options.databaseProvider === "postgres/typeorm" || Boolean(pkg?.hasScript("db:up"));
+    const hasAuth0 = options.authProvider === "auth0" || Boolean(env?.hasEntry("AUTH0_ISSUER_BASE_URL"));
+    const hasPostman = options.postmanProvider === "local" || options.postmanProvider === "api" || (0, _nodefs.existsSync)((0, _nodepath.join)(workspace.targetDir, "postman")) || (0, _nodefs.existsSync)((0, _nodepath.join)(workspace.targetDir, ".postman"));
+    return {
+        projectName: workspace.name,
+        apiNames,
+        hasPostgres,
+        hasAuth0,
+        hasPostman
+    };
+}
+function writeWorkspaceReadme(workspace, options) {
+    const content = renderWorkspaceReadme(resolveWorkspaceReadmeInput(workspace, options));
+    workspace.addFile({
+        files: ()=>[
+                {
+                    filePath: "README.md",
+                    content
+                }
+            ]
+    });
+}
+function mergeApiNames(existing, added) {
+    const seen = new Set(existing);
+    return [
+        ...existing,
+        ...added.filter((name)=>!seen.has(name))
+    ];
+}

package/commonjs/src/webapi.action.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WebapiAction", {
+    enumerable: true,
+    get: function() {
+        return WebapiAction;
+    }
+});
+const _decorators = require("@decohere/crucible/decorators");
+const _cli = require("@decohere/devkit/cli");
+const _clioptions = require("./webapi/cli-options.js");
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+class WebapiAction {
+    async run(options) {
+        await (0, _clioptions.runScaffoldApi)((0, _clioptions.toApiOptions)(options.directory, options));
+        return _cli.ActionResponse.Success("webapi");
+    }
+}
+WebapiAction = _ts_decorate([
+    (0, _decorators.injectable)()
+], WebapiAction);

package/commonjs/src/webapi.command.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "WebapiCommand", {
+    enumerable: true,
+    get: function() {
+        return WebapiCommand;
+    }
+});
+const _cli = require("@decohere/devkit/cli");
+const _clioptions = require("./webapi/cli-options.js");
+const _webapiaction = require("./webapi.action.js");
+class WebapiCommand extends _cli.DecohereCommand {
+    get actions() {
+        return [
+            _webapiaction.WebapiAction
+        ];
+    }
+    constructor(name){
+        super(name);
+        this.description("Scaffold a web API workspace");
+        this.argument("[directory]", "Target directory (default: -d or current directory)");
+        this.option("-d <directory>", "Target directory (default: current directory)", ".");
+        this.option("--name <slug>", "API name under projects/ (repeatable; default: api)", _clioptions.collectName, []);
+        (0, _clioptions.addWebapiFeatureOptions)(this);
+    }
+    /**
+	 * Commander passes positional args before options when `[directory]` is declared.
+	 * ModuleFactory expects `(opts, cmd)` — stash the directory on the command.
+	 */ action(fn) {
+        return super.action((...args)=>{
+            const cmd = args.at(-1);
+            const first = args[0];
+            const hasPositional = typeof first === "string" || first === undefined;
+            const opts = hasPositional ? args[1] : args[0];
+            if (typeof first === "string" && first !== "") {
+                cmd.setOptionValue("directory", first);
+            }
+            return fn(opts, cmd);
+        });
+    }
+}

package/es6/src/add-api.action.js

@@ -0,0 +1,27 @@
+function _ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for(var i = decorators.length - 1; i >= 0; i--)if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+import { injectable } from "@decohere/crucible/decorators";
+import { ActionResponse } from "@decohere/devkit/cli";
+import { runScaffoldApi, toApiOptions } from "./webapi/cli-options.js";
+export class AddApiAction {
+    async run(options) {
+        const name = options.apiName;
+        if (name == null || name === "") {
+            return ActionResponse.Error("api", "API name is required");
+        }
+        await runScaffoldApi(toApiOptions(undefined, options, {
+            names: [
+                name
+            ],
+            add: true
+        }));
+        return ActionResponse.Success("api");
+    }
+}
+AddApiAction = _ts_decorate([
+    injectable()
+], AddApiAction);

package/es6/src/add-api.command.js

@@ -0,0 +1,29 @@
+import { DecohereCommand } from "@decohere/devkit/cli";
+import { AddApiAction } from "./add-api.action.js";
+import { addWebapiFeatureOptions } from "./webapi/cli-options.js";
+export class AddApiCommand extends DecohereCommand {
+    get actions() {
+        return [
+            AddApiAction
+        ];
+    }
+    constructor(name){
+        super(name);
+        this.description("Add an API to an existing Decohere workspace");
+        this.argument("<name>", "API name under projects/");
+        this.option("-d <directory>", "Workspace directory (default: current directory)", ".");
+        addWebapiFeatureOptions(this);
+    }
+    action(fn) {
+        return super.action((...args)=>{
+            const cmd = args.at(-1);
+            const first = args[0];
+            const hasPositional = typeof first === "string" || first === undefined;
+            const opts = hasPositional ? args[1] : args[0];
+            if (typeof first === "string" && first !== "") {
+                cmd.setOptionValue("apiName", first);
+            }
+            return fn(opts, cmd);
+        });
+    }
+}

package/es6/src/add.command.js

@@ -0,0 +1,12 @@
+import { DecohereCommand } from "@decohere/devkit/cli";
+export class AddCommand extends DecohereCommand {
+    constructor(commands, handler){
+        super(AddCommand);
+        this.description("Add to an existing Decohere workspace");
+        this.exitOverride();
+        this.registerSubcommand(commands, handler);
+    }
+    run(_actions, _options) {
+        return this.help();
+    }
+}