@cargo-ai/cli 1.0.25 → 1.0.26

package/build/commands/cdk/init.js

@@ -0,0 +1,86 @@
+import { existsSync, readdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { ExitCodes, failWith, info, success } from "../runHandler.js";
+import { copyDirectory, listTemplates } from "../templateUtils.js";
+const require = createRequire(import.meta.url);
+// `cargo-ai cdk init <directory> [--template <slug>]` — scaffold a starter CDK
+// project by copying one of `@cargo-ai/cdk`'s templates (see `--list-templates`),
+// substituting `__APP_NAME__`. Mirrors the hosting app/worker `init` commands.
+const TEMPLATE_DESCRIPTIONS = {
+    blank: "Minimal starter — one connector + model + a workflow-backed tool. Good starting point.",
+    full: "The full example — every resource type wired into a GTM growth workspace: connectors, models, plays, agents, an MCP server, context, tools, a worker, and a hosted app.",
+};
+export function registerInitCommand(parent) {
+    parent
+        .command("init <directory>")
+        .description("Scaffold a starter Cargo CDK project locally from a template (ready to plan/deploy).")
+        .option("--template <slug>", "Template slug (default: blank)", "blank")
+        .option("--name <name>", "Project name written into package.json")
+        .option("--list-templates", "Print available templates and exit")
+        .option("--force", "Write into a non-empty directory")
+        .action(async (directory, opts) => {
+        const templatesRoot = findTemplatesRoot();
+        if (opts.listTemplates === true) {
+            const slugs = await listTemplates(templatesRoot);
+            for (const slug of slugs) {
+                const desc = TEMPLATE_DESCRIPTIONS[slug] ?? "";
+                info(`${slug}${desc.length > 0 ? ` — ${desc}` : ""}`);
+            }
+            return;
+        }
+        const templateDir = join(templatesRoot, opts.template);
+        if (!existsSync(templateDir)) {
+            const slugs = await listTemplates(templatesRoot);
+            failWith(`Unknown template "${opts.template}". Available: ${slugs.join(", ")}`, { code: ExitCodes.GenericError });
+        }
+        const targetDir = resolve(process.cwd(), directory);
+        if (existsSync(targetDir) &&
+            readdirSync(targetDir).length > 0 &&
+            opts.force !== true) {
+            failWith(`Directory ${directory} is not empty. Pass --force to scaffold into it anyway.`, { code: ExitCodes.GenericError });
+        }
+        const appName = opts.name !== undefined ? opts.name : basename(targetDir);
+        await copyDirectory(templateDir, targetDir, [
+            { from: "__APP_NAME__", to: appName },
+        ]);
+        success(`Scaffolded ${directory} from the "${opts.template}" template`);
+        info(``);
+        info([
+            `Next steps:`,
+            `  cd ${relative(process.cwd(), targetDir)}`,
+            `  npm install`,
+            `  cargo-ai login                 # authenticate to your workspace`,
+            `  cargo-ai cdk types             # generate typed connector/model config`,
+            `  cargo-ai cdk plan              # preview the resource tree`,
+            `  cargo-ai cdk deploy            # create it in the workspace`,
+        ].join("\n"));
+    });
+}
+// Templates live in `@cargo-ai/cdk/templates`. Resolve the package entry and walk
+// up to the package root that holds `templates/` — works whether the CDK was
+// installed from npm or came from the monorepo.
+function findTemplatesRoot() {
+    try {
+        const entry = require.resolve("@cargo-ai/cdk");
+        let cursor = dirname(entry);
+        for (let i = 0; i < 6; i += 1) {
+            const candidate = join(cursor, "templates");
+            if (existsSync(candidate))
+                return candidate;
+            cursor = dirname(cursor);
+        }
+    }
+    catch {
+        // Fall through to the monorepo-relative lookup.
+    }
+    let cursor = dirname(fileURLToPath(import.meta.url));
+    for (let i = 0; i < 8; i += 1) {
+        const candidate = join(cursor, "packages/cdk/templates");
+        if (existsSync(candidate))
+            return candidate;
+        cursor = dirname(cursor);
+    }
+    throw new Error("Could not locate @cargo-ai/cdk templates. Make sure @cargo-ai/cdk is installed alongside @cargo-ai/cli.");
+}

package/build/commands/{workflow → cdk}/inputTypes.d.ts

@@ -9,6 +9,12 @@ export declare const AGENT_INPUT_TYPE_SRC: string;
  * object schema we can render.
  */
 export declare function printJsonSchemaInput(schema: unknown): string;
+/**
+ * Like {@link printJsonSchemaInput} but WITHOUT the top-level `Ref<T> | T`
+ * widening — for CDK connector/model config types, which are plain data (no
+ * workflow builder Refs). Used by `cargo-ai cdk types`.
+ */
+export declare function printJsonSchemaType(schema: unknown): string;
 /**
  * Print a tool release's `formFields` as a TS input type. Returns
  * `undefined` when the fields can't be interpreted (caller falls back to

package/build/commands/cdk/inputTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inputTypes.d.ts","sourceRoot":"","sources":["../../../src/commands/cdk/inputTypes.ts"],"names":[],"mappings":"AAmCA;;;GAGG;AACH,eAAO,MAAM,oBAAoB,QAE+D,CAAC;AAEjG;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAM5D;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,CAQ3D;AAkMD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAU5E"}

package/build/commands/{workflow → cdk}/inputTypes.js

@@ -30,12 +30,42 @@ export function printJsonSchemaInput(schema) {
     if (schema === null || typeof schema !== "object") {
         return "Record<string, unknown>";
     }
-    const printed = printSchema(schema, true);
+    const printed = printSchema(schema, true, false);
     return printed === "unknown" ? "Record<string, unknown>" : printed;
 }
-function printSchema(schema, topLevel) {
+/**
+ * Like {@link printJsonSchemaInput} but WITHOUT the top-level `Ref<T> | T`
+ * widening — for CDK connector/model config types, which are plain data (no
+ * workflow builder Refs). Used by `cargo-ai cdk types`.
+ */
+export function printJsonSchemaType(schema) {
+    if (schema === null || typeof schema !== "object") {
+        return "Record<string, unknown>";
+    }
+    // encRef=true: print `EncryptionRef` at encryption-typed fields so only those
+    // accept a `secret()`.
+    const printed = printSchema(schema, false, true);
+    return printed === "unknown" ? "Record<string, unknown>" : printed;
+}
+// The platform's shared `encryption` schema definition: an object with a `type`
+// const/enum of "encryption" plus `isEncrypted` and `value`. In CDK config types
+// these positions become `EncryptionRef` (see printObject).
+function isEncryptionSchema(schema) {
+    const props = schema.properties;
+    if (props === undefined)
+        return false;
+    const typeProp = props["type"];
+    if (typeProp === undefined)
+        return false;
+    const isEnc = typeProp.const === "encryption" ||
+        (Array.isArray(typeProp.enum) &&
+            typeProp.enum.length === 1 &&
+            typeProp.enum[0] === "encryption");
+    return (isEnc && props["isEncrypted"] !== undefined && props["value"] !== undefined);
+}
+function printSchema(schema, topLevel, encRef) {
     if (Array.isArray(schema.type)) {
-        return uniqueUnion(schema.type.map((t) => printPrimitive(t, schema, false)));
+        return uniqueUnion(schema.type.map((t) => printPrimitive(t, schema, false, encRef)));
     }
     if (schema.enum !== undefined && schema.enum.length > 0) {
         return schema.enum.map((v) => JSON.stringify(v)).join(" | ");
@@ -44,20 +74,26 @@ function printSchema(schema, topLevel) {
         return JSON.stringify(schema.const);
     }
     if (schema.oneOf !== undefined && schema.oneOf.length > 0) {
-        return uniqueUnion(schema.oneOf.map((s) => printSchema(s, false)));
+        return uniqueUnion(schema.oneOf.map((s) => printSchema(s, false, encRef)));
     }
     if (schema.anyOf !== undefined && schema.anyOf.length > 0) {
-        return uniqueUnion(schema.anyOf.map((s) => printSchema(s, false)));
+        return uniqueUnion(schema.anyOf.map((s) => printSchema(s, false, encRef)));
     }
     if (schema.allOf !== undefined && schema.allOf.length > 0) {
-        // Conservative: render the head rather than a TS intersection.
-        return printSchema(schema.allOf[0], topLevel);
+        // Connectors model "pick an auth method, then its fields" as an object with
+        // a discriminant property plus `allOf: [{ if, then, else }]`. Expand that to
+        // a discriminated union (e.g. HubSpot → `{ method: "privateApp"; … } | { …
+        // "oauth"; … }`); otherwise fall back to rendering the head.
+        const conditional = printConditionalObject(schema, topLevel, encRef);
+        if (conditional !== undefined)
+            return conditional;
+        return printSchema(schema.allOf[0], topLevel, encRef);
     }
     if (typeof schema.type !== "string")
         return "unknown";
-    return printPrimitive(schema.type, schema, topLevel);
+    return printPrimitive(schema.type, schema, topLevel, encRef);
 }
-function printPrimitive(type, schema, topLevel) {
+function printPrimitive(type, schema, topLevel, encRef) {
     switch (type) {
         case "string":
             return "string";
@@ -69,34 +105,96 @@ function printPrimitive(type, schema, topLevel) {
         case "null":
             return "null";
         case "array":
-            return printArray(schema);
+            return printArray(schema, encRef);
         case "object":
-            return printObject(schema, topLevel);
+            return printObject(schema, topLevel, encRef);
         default:
             return "unknown";
     }
 }
-function printArray(schema) {
+// Expand the connector "discriminant + allOf[{ if, then, else }]" pattern into a
+// discriminated union. Returns undefined when the schema isn't that shape (the
+// caller then falls back to rendering the allOf head).
+function printConditionalObject(schema, topLevel, encRef) {
+    const props = schema.properties;
+    if (props === undefined || schema.allOf === undefined)
+        return undefined;
+    const block = schema.allOf.find((a) => a.if !== undefined);
+    if (block === undefined || block.if?.properties === undefined)
+        return undefined;
+    // The discriminant: the single property the `if` tests, and its `const` value.
+    const ifEntries = Object.entries(block.if.properties);
+    if (ifEntries.length !== 1)
+        return undefined;
+    const [discKey, discCond] = ifEntries[0];
+    const thenValue = discCond.const;
+    if (thenValue === undefined)
+        return undefined;
+    // All the discriminant's allowed values, from its own oneOf/enum consts.
+    const discSchema = props[discKey];
+    const values = discriminantValues(discSchema);
+    if (values.length === 0)
+        return undefined;
+    const baseRequired = Array.isArray(schema.required) ? schema.required : [];
+    const branches = values.map((value) => {
+        const isThen = value === thenValue;
+        const extra = isThen ? block.then : block.else;
+        const branchProps = {
+            ...props,
+            [discKey]: { const: value },
+        };
+        if (extra?.properties !== undefined) {
+            Object.assign(branchProps, extra.properties);
+        }
+        const required = new Set(baseRequired);
+        if (Array.isArray(extra?.required)) {
+            for (const r of extra.required)
+                required.add(r);
+        }
+        return printSchema({ type: "object", properties: branchProps, required: [...required] }, topLevel, encRef);
+    });
+    return uniqueUnion(branches);
+}
+function discriminantValues(schema) {
+    if (schema === undefined)
+        return [];
+    if (schema.const !== undefined)
+        return [schema.const];
+    if (Array.isArray(schema.enum))
+        return schema.enum;
+    const variants = schema.oneOf ?? schema.anyOf;
+    if (Array.isArray(variants)) {
+        const consts = variants.map((v) => v.const).filter((v) => v !== undefined);
+        if (consts.length > 0)
+            return consts;
+    }
+    return [];
+}
+function printArray(schema, encRef) {
     if (schema.items === undefined)
         return "unknown[]";
     if (Array.isArray(schema.items)) {
-        return `[${schema.items.map((s) => printSchema(s, false)).join(", ")}]`;
+        return `[${schema.items.map((s) => printSchema(s, false, encRef)).join(", ")}]`;
     }
-    return `Array<${printSchema(schema.items, false)}>`;
+    return `Array<${printSchema(schema.items, false, encRef)}>`;
 }
-function printObject(schema, topLevel) {
+function printObject(schema, topLevel, encRef) {
+    // An encryption-typed field becomes `EncryptionRef` (which accepts `secret()`)
+    // — but only in CDK config mode; workflow input types print it structurally.
+    if (encRef && isEncryptionSchema(schema))
+        return "EncryptionRef";
     const props = schema.properties;
     if (props === undefined) {
         if (typeof schema.additionalProperties === "object" &&
             schema.additionalProperties !== null) {
-            return `Record<string, ${printSchema(schema.additionalProperties, false)}>`;
+            return `Record<string, ${printSchema(schema.additionalProperties, false, encRef)}>`;
         }
         return "Record<string, unknown>";
     }
     const required = new Set(Array.isArray(schema.required) ? schema.required : []);
     const fields = [];
     for (const [key, child] of Object.entries(props)) {
-        const inner = printSchema(child, false);
+        const inner = printSchema(child, false, encRef);
         // Only top-level properties are Ref-widened; nested values are plain.
         const value = topLevel ? `Ref<${inner}> | ${inner}` : inner;
         const opt = required.has(key) ? "" : "?";

package/build/commands/cdk/types.d.ts

@@ -0,0 +1,4 @@
+import type { Command } from "commander";
+import type { Api } from "../../api.js";
+export declare function registerTypesCommand(parent: Command, getApi: () => Api): void;
+//# sourceMappingURL=types.d.ts.map

package/build/commands/cdk/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/commands/cdk/types.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AA0FxC,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,IAAI,CA8D7E"}