@program-video/cli 0.1.9 → 0.1.11

package/dist/index.js

@@ -872,6 +872,16 @@ function inferMimeType(fileName) {
   const extension = path2.extname(fileName).toLowerCase();
   return MIME_TYPES_BY_EXTENSION[extension] ?? null;
 }
+function normalizeToolParams(toolName, params) {
+  if (toolName !== "addScene") {
+    return params;
+  }
+  const next = { ...params };
+  if (typeof next.name === "string" && next.name.length > 0 && (typeof next.title !== "string" || next.title.length === 0)) {
+    next.title = next.name;
+  }
+  return next;
+}
 async function uploadFileFromPath(params, projectId, accessToken, source) {
   const filePath = params.path;
   if (typeof filePath !== "string" || filePath.length === 0) {
@@ -900,31 +910,79 @@ async function uploadFileFromPath(params, projectId, accessToken, source) {
     throw new Error("category must match /^[a-z0-9_-]{1,32}$/i");
   }
   const metadata = params.metadata && typeof params.metadata === "object" ? params.metadata : void 0;
-  const fileStream = createReadStream(filePath);
-  const uploadRequest = {
+  const initRequest = {
     method: "POST",
     headers: {
       Authorization: `Bearer ${accessToken}`,
-      "Content-Type": mimeType,
-      "Content-Length": String(fileStat.size),
+      "Content-Type": "application/json",
       "x-project-id": projectId,
-      "x-file-name": encodeURIComponent(fileName),
-      "x-file-size": String(fileStat.size),
-      ...category ? { "x-category": category } : {},
-      ...metadata ? { "x-metadata": JSON.stringify(metadata) } : {},
       ...source ? { "x-source": source } : {}
     },
+    body: JSON.stringify({
+      step: "init",
+      fileName,
+      mimeType,
+      fileSize: fileStat.size,
+      category,
+      metadata
+    })
+  };
+  const initResponse = await fetch(`${BASE_URL}/api/cli/upload`, initRequest);
+  const initResult = await initResponse.json().catch(() => null);
+  if (!initResponse.ok || !initResult?.success || !initResult.data) {
+    throw new Error(
+      initResult?.error ?? `Upload init failed (${initResponse.status})`
+    );
+  }
+  const fileStream = createReadStream(filePath);
+  const uploadRequest = {
+    method: "POST",
+    headers: {
+      "Content-Type": mimeType,
+      "Content-Length": String(fileStat.size)
+    },
     body: fileStream,
     duplex: "half"
   };
-  const response = await fetch(`${BASE_URL}/api/cli/upload`, uploadRequest);
-  const result = await response.json().catch(() => null);
-  if (!response.ok || !result?.success) {
+  const storageUploadResponse = await fetch(
+    initResult.data.uploadUrl,
+    uploadRequest
+  );
+  const storageUploadJson = await storageUploadResponse.json().catch(() => null);
+  if (!storageUploadResponse.ok || !storageUploadJson || typeof storageUploadJson.storageId !== "string") {
+    throw new Error(
+      `Failed to upload bytes to storage (${storageUploadResponse.status})`
+    );
+  }
+  const finalizeRequest = {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      "x-project-id": projectId,
+      ...source ? { "x-source": source } : {}
+    },
+    body: JSON.stringify({
+      step: "finalize",
+      storageId: storageUploadJson.storageId,
+      fileName,
+      mimeType,
+      fileSize: fileStat.size,
+      category,
+      metadata
+    })
+  };
+  const finalizeResponse = await fetch(
+    `${BASE_URL}/api/cli/upload`,
+    finalizeRequest
+  );
+  const finalizeResult = await finalizeResponse.json().catch(() => null);
+  if (!finalizeResponse.ok || !finalizeResult?.success) {
     throw new Error(
-      result?.error ?? `File upload failed (${response.status})`
+      finalizeResult?.error ?? `File finalize failed (${finalizeResponse.status})`
     );
   }
-  return result;
+  return finalizeResult;
 }
 async function executeCommand(toolName, options) {
   const showSpinner = !options.json && process.stdout.isTTY;
@@ -940,6 +998,7 @@ async function executeCommand(toolName, options) {
   if (options.params) {
     try {
       params = JSON.parse(options.params);
+      params = normalizeToolParams(toolName, params);
     } catch {
       spinner?.stop();
       spinner?.clear();
@@ -1369,40 +1428,1048 @@ For agent integration, always use the --json flag.
 `);
 }
 
-// src/index.ts
-var program = new Command();
-var require2 = createRequire(import.meta.url);
-var packageJson = require2("../package.json");
-program.name("program").description("CLI for the Program video creation platform").version(packageJson.version);
-var auth = program.command("auth").description("Authentication commands");
-auth.command("login").description("Authenticate with the Program platform").option("--json", "Output as JSON").action(async (options) => {
-  await loginCommand(options);
-});
-auth.command("logout").description("Log out from the Program platform").option("--json", "Output as JSON").action((options) => {
-  logoutCommand(options);
-});
-auth.command("status").description("Check authentication status").option("--json", "Output as JSON").action((options) => {
-  statusCommand(options);
-});
-var project = program.command("project").description("Project management commands");
-project.command("create").description("Create a new project").option("--title <title>", "Project title").option("--description <description>", "Project description").option("--json", "Output as JSON").action(async (options) => {
-  await createCommand(options);
-});
-project.command("list").description("List projects").option("--limit <limit>", "Maximum number of projects to return", parseInt).option("--json", "Output as JSON").action(async (options) => {
-  await listCommand(options);
-});
-project.command("get <id>").description("Get project details including composition").option("--json", "Output as JSON").action(async (id, options) => {
-  await getCommand(id, options);
-});
-var workflow = program.command("workflow").description("Workflow template commands");
-workflow.command("list").description("List available workflow templates").option("--limit <limit>", "Maximum number of templates to return", parseInt).option("--public-only", "Only show public templates").option("--json", "Output as JSON").action(async (options) => {
-  await listCommand2(options);
-});
-workflow.command("run <templateId>").description("Execute a workflow template").option("--project <projectId>", "Project ID to associate with execution").option("--input <json>", "JSON input for the workflow").option("--json", "Output as JSON").action(async (templateId, options) => {
-  await runCommand(templateId, options);
+// src/commands/template/list.ts
+import chalk14 from "chalk";
+import ora12 from "ora";
+async function listCommand5(options) {
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora12("Fetching templates...").start() : null;
+  const client = createConvexClient(convexConfig);
+  const result = await client.query("templates.list", {
+    category: options.publicOnly ? "public" : void 0
+  });
+  spinner?.stop();
+  spinner?.clear();
+  if (!result.success || !result.data) {
+    outputError(result.error ?? "Failed to list templates", options);
+    process.exit(1);
+  }
+  const templates = result.data;
+  if (options.json) {
+    outputSuccess(
+      templates.map((t) => ({
+        id: t._id,
+        name: t.name,
+        description: t.description,
+        public: t.public,
+        stepCount: Array.isArray(t.steps) ? t.steps.length : 0
+      })),
+      options
+    );
+  } else {
+    if (templates.length === 0) {
+      console.log(chalk14.dim("No templates found."));
+      return;
+    }
+    console.log(
+      `Found ${chalk14.cyan(templates.length)} template${templates.length === 1 ? "" : "s"}:
+`
+    );
+    const rows = templates.map((t) => [
+      t._id,
+      t.name,
+      t.description?.substring(0, 40) ?? chalk14.dim("No description"),
+      String(Array.isArray(t.steps) ? t.steps.length : 0),
+      t.public ? chalk14.green("public") : chalk14.dim("private")
+    ]);
+    console.log(
+      formatTable(["ID", "Name", "Description", "Steps", "Visibility"], rows)
+    );
+  }
+}
+
+// src/commands/template/get.ts
+import chalk15 from "chalk";
+import ora13 from "ora";
+
+// src/lib/context.ts
+import Conf2 from "conf";
+import * as fs3 from "fs";
+import * as path3 from "path";
+import * as os2 from "os";
+var CONTEXT_DIR = path3.join(os2.homedir(), ".program");
+function ensureContextDir() {
+  if (!fs3.existsSync(CONTEXT_DIR)) {
+    fs3.mkdirSync(CONTEXT_DIR, { mode: 448, recursive: true });
+  }
+}
+var store2 = new Conf2({
+  projectName: "program-cli",
+  cwd: CONTEXT_DIR,
+  configName: "context",
+  fileExtension: "json",
+  defaults: {
+    activeTemplateId: null
+  }
 });
-workflow.command("status <executionId>").description("Check workflow execution status").option("--watch", "Continuously poll for status updates").option("--interval <ms>", "Poll interval in milliseconds", parseInt).option("--json", "Output as JSON").action(async (executionId, options) => {
-  await statusCommand2(executionId, options);
+function setActiveTemplate(id) {
+  ensureContextDir();
+  store2.set("activeTemplateId", id);
+}
+function getActiveTemplate() {
+  return store2.get("activeTemplateId");
+}
+function clearActiveTemplate() {
+  store2.set("activeTemplateId", null);
+}
+
+// src/commands/template/get.ts
+async function getCommand2(id, options) {
+  const templateId = id ?? getActiveTemplate();
+  if (!templateId) {
+    outputError(
+      "No template ID provided and no active template set. Use 'template use <id>' to set one.",
+      options
+    );
+    process.exit(1);
+  }
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora13("Fetching template...").start() : null;
+  const client = createConvexClient(convexConfig);
+  const result = await client.query("templates.byId", {
+    id: templateId
+  });
+  spinner?.stop();
+  spinner?.clear();
+  if (!result.success || !result.data) {
+    outputError(result.error ?? "Template not found", options);
+    process.exit(1);
+  }
+  const template2 = result.data;
+  if (options.json) {
+    outputSuccess(template2, options);
+  } else {
+    console.log(
+      formatKeyValue([
+        { key: "ID", value: template2._id },
+        { key: "Name", value: template2.name },
+        {
+          key: "Description",
+          value: template2.description ?? chalk15.dim("None")
+        },
+        {
+          key: "Visibility",
+          value: template2.public ? chalk15.green("public") : chalk15.dim("private")
+        },
+        {
+          key: "Created",
+          value: new Date(template2.createdAt).toLocaleString()
+        },
+        {
+          key: "Updated",
+          value: new Date(template2.updatedAt).toLocaleString()
+        }
+      ])
+    );
+    const steps = template2.steps ?? [];
+    if (steps.length === 0) {
+      console.log(chalk15.dim("\nNo steps configured."));
+    } else {
+      console.log(`
+${chalk15.bold("Steps")} (${steps.length}):
+`);
+      const rows = steps.map((s, i) => [
+        String(i),
+        s.id ?? chalk15.dim("\u2014"),
+        s.stepId,
+        summarizeConfig(s.config)
+      ]);
+      console.log(formatTable(["#", "ID", "Type", "Config"], rows));
+    }
+  }
+}
+function summarizeConfig(config) {
+  const keys = Object.keys(config);
+  if (keys.length === 0) return chalk15.dim("{}");
+  const summary = keys.slice(0, 3).map((k) => {
+    const v = config[k];
+    const vs = typeof v === "string" ? v.length > 20 ? v.substring(0, 20) + "..." : v : JSON.stringify(v);
+    return `${k}=${vs}`;
+  }).join(", ");
+  return keys.length > 3 ? summary + `, +${keys.length - 3} more` : summary;
+}
+
+// src/commands/template/create.ts
+import chalk16 from "chalk";
+import ora14 from "ora";
+async function createCommand2(options) {
+  if (!options.name) {
+    outputError("--name is required", options);
+    process.exit(1);
+  }
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora14("Creating template...").start() : null;
+  const client = createConvexClient(convexConfig);
+  const result = await client.mutation("templates.create", {
+    name: options.name,
+    description: options.description,
+    public: options.public ?? false
+  });
+  spinner?.stop();
+  spinner?.clear();
+  if (!result.success || !result.data) {
+    outputError(result.error ?? "Failed to create template", options);
+    process.exit(1);
+  }
+  const templateId = result.data;
+  setActiveTemplate(templateId);
+  if (options.json) {
+    outputSuccess({ id: templateId, active: true }, options);
+  } else {
+    console.log(formatSuccess("Template created (now active)"));
+    console.log(chalk16.dim(`  ID: ${templateId}`));
+  }
+}
+
+// src/commands/template/update.ts
+import ora15 from "ora";
+async function updateCommand(id, options) {
+  const templateId = id ?? getActiveTemplate();
+  if (!templateId) {
+    outputError(
+      "No template ID provided and no active template set. Use 'template use <id>' to set one.",
+      options
+    );
+    process.exit(1);
+  }
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora15("Updating template...").start() : null;
+  const client = createConvexClient(convexConfig);
+  const params = { id: templateId };
+  if (options.name !== void 0) params.name = options.name;
+  if (options.description !== void 0) params.description = options.description;
+  if (options.public !== void 0) params.public = options.public;
+  const result = await client.mutation("templates.update", params);
+  spinner?.stop();
+  spinner?.clear();
+  if (!result.success) {
+    outputError(result.error ?? "Failed to update template", options);
+    process.exit(1);
+  }
+  if (options.json) {
+    outputSuccess({ id: templateId, updated: true }, options);
+  } else {
+    console.log(formatSuccess("Template updated"));
+  }
+}
+
+// src/commands/template/remove.ts
+import chalk17 from "chalk";
+import ora16 from "ora";
+async function removeCommand(id, options) {
+  const templateId = id ?? getActiveTemplate();
+  if (!templateId) {
+    outputError(
+      "No template ID provided and no active template set. Use 'template use <id>' to set one.",
+      options
+    );
+    process.exit(1);
+  }
+  if (!options.force && !options.json) {
+    const readline = await import("readline");
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    const answer = await new Promise((resolve) => {
+      rl.question(
+        chalk17.yellow(`Are you sure you want to delete template ${templateId}? (y/N) `),
+        resolve
+      );
+    });
+    rl.close();
+    if (answer.toLowerCase() !== "y") {
+      console.log(chalk17.dim("Cancelled."));
+      return;
+    }
+  }
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora16("Deleting template...").start() : null;
+  const client = createConvexClient(convexConfig);
+  const result = await client.mutation("templates.remove", {
+    id: templateId
+  });
+  spinner?.stop();
+  spinner?.clear();
+  if (!result.success) {
+    outputError(result.error ?? "Failed to delete template", options);
+    process.exit(1);
+  }
+  if (getActiveTemplate() === templateId) {
+    clearActiveTemplate();
+  }
+  if (options.json) {
+    outputSuccess({ id: templateId, deleted: true }, options);
+  } else {
+    console.log(formatSuccess("Template deleted"));
+  }
+}
+
+// src/commands/template/run.ts
+import chalk18 from "chalk";
+import ora17 from "ora";
+async function runCommand2(id, options) {
+  const templateId = id ?? getActiveTemplate();
+  if (!templateId) {
+    outputError(
+      "No template ID provided and no active template set. Use 'template use <id>' to set one.",
+      options
+    );
+    process.exit(1);
+  }
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora17("Starting workflow execution...").start() : null;
+  let input;
+  if (options.input) {
+    try {
+      input = JSON.parse(options.input);
+    } catch {
+      spinner?.stop();
+      spinner?.clear();
+      outputError("Invalid JSON in --input parameter", options);
+      process.exit(1);
+    }
+  }
+  const client = createConvexClient(convexConfig);
+  const result = await client.mutation("workflows.run", {
+    templateId,
+    projectId: options.project,
+    input
+  });
+  spinner?.stop();
+  spinner?.clear();
+  if (!result.success || !result.data) {
+    outputError(result.error ?? "Failed to start workflow", options);
+    process.exit(1);
+  }
+  const executionId = result.data;
+  if (options.json) {
+    outputSuccess({ executionId }, options);
+  } else {
+    console.log(formatSuccess("Workflow started"));
+    console.log(chalk18.dim(`  Execution ID: ${executionId}`));
+    console.log(
+      chalk18.dim(`  Check status with: program template status ${executionId}`)
+    );
+  }
+}
+
+// src/commands/template/status.ts
+import chalk19 from "chalk";
+import ora18 from "ora";
+async function statusCommand3(executionId, options) {
+  const client = createConvexClient(convexConfig);
+  const pollInterval = options.interval ?? 2e3;
+  if (options.watch) {
+    await watchStatus2(client, executionId, pollInterval, options);
+  } else {
+    await getStatusOnce2(client, executionId, options);
+  }
+}
+async function getStatusOnce2(client, executionId, options) {
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora18("Fetching execution status...").start() : null;
+  const result = await client.query("workflows.status", {
+    executionId
+  });
+  spinner?.stop();
+  spinner?.clear();
+  if (!result.success) {
+    outputError(result.error ?? "Failed to get status", options);
+    process.exit(1);
+  }
+  const status = result.data;
+  if (!status) {
+    outputError("Execution not found", options);
+    process.exit(1);
+  }
+  if (options.json) {
+    outputSuccess(status, options);
+  } else {
+    printStatus2(status);
+  }
+}
+async function watchStatus2(client, executionId, pollInterval, options) {
+  let lastStatus = null;
+  const poll = async () => {
+    const result = await client.query("workflows.status", {
+      executionId
+    });
+    if (!result.success) {
+      outputError(result.error ?? "Failed to get status", options);
+      return true;
+    }
+    const status = result.data;
+    if (!status) {
+      outputError("Execution not found", options);
+      return true;
+    }
+    if (options.json) {
+      if (status.status !== lastStatus) {
+        console.log(JSON.stringify(status));
+        lastStatus = status.status;
+      }
+    } else {
+      if (status.status !== lastStatus) {
+        console.clear();
+        console.log(chalk19.dim(`Watching execution ${executionId}...
+`));
+        printStatus2(status);
+        lastStatus = status.status;
+      }
+    }
+    if (["success", "error", "cancelled"].includes(status.status)) {
+      return true;
+    }
+    return false;
+  };
+  let done = await poll();
+  while (!done) {
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    done = await poll();
+  }
+}
+function printStatus2(status) {
+  const statusColor = getStatusColor2(status.status);
+  console.log(
+    formatKeyValue([
+      { key: "Status", value: statusColor(status.status) },
+      ...status.completedAt ? [
+        {
+          key: "Completed",
+          value: new Date(status.completedAt).toLocaleString()
+        }
+      ] : []
+    ])
+  );
+  if (status.nodeStatuses && status.nodeStatuses.length > 0) {
+    console.log(chalk19.dim("\nStep progress:"));
+    for (const node of status.nodeStatuses) {
+      const nodeColor = getStatusColor2(node.status);
+      console.log(`  ${nodeColor(getStatusIcon2(node.status))} ${node.nodeId}`);
+    }
+  }
+  if (status.error) {
+    console.log(formatWarning(`
+Error: ${status.error}`));
+  }
+  if (status.status === "success" && status.output) {
+    console.log(formatSuccess("\nOutput:"));
+    console.log(JSON.stringify(status.output, null, 2));
+  }
+}
+function getStatusColor2(status) {
+  switch (status) {
+    case "success":
+      return chalk19.green;
+    case "error":
+      return chalk19.red;
+    case "cancelled":
+      return chalk19.yellow;
+    case "running":
+      return chalk19.blue;
+    case "pending":
+    default:
+      return chalk19.dim;
+  }
+}
+function getStatusIcon2(status) {
+  switch (status) {
+    case "success":
+      return "\u2713";
+    case "error":
+      return "\u2715";
+    case "running":
+      return "\u25CF";
+    case "pending":
+    default:
+      return "\u25CB";
+  }
+}
+
+// src/commands/template/use.ts
+import chalk20 from "chalk";
+import ora19 from "ora";
+async function useCommand(id, options) {
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora19("Verifying template...").start() : null;
+  const client = createConvexClient(convexConfig);
+  const result = await client.query("templates.byId", { id });
+  spinner?.stop();
+  spinner?.clear();
+  if (!result.success || !result.data) {
+    outputError(result.error ?? "Template not found or not accessible", options);
+    process.exit(1);
+  }
+  setActiveTemplate(id);
+  if (options.json) {
+    outputSuccess({ id, name: result.data.name, active: true }, options);
+  } else {
+    console.log(formatSuccess(`Active template set to "${result.data.name}"`));
+    console.log(chalk20.dim(`  ID: ${id}`));
+  }
+}
+
+// src/commands/template/step/list.ts
+import chalk21 from "chalk";
+import ora20 from "ora";
+async function stepListCommand(options) {
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora20("Fetching step types...").start() : null;
+  const client = createConvexClient(convexConfig);
+  const result = await client.query("templates.steps", {
+    category: options.category
+  });
+  spinner?.stop();
+  spinner?.clear();
+  if (!result.success || !result.data) {
+    outputError(result.error ?? "Failed to list step types", options);
+    process.exit(1);
+  }
+  const steps = result.data;
+  if (options.json) {
+    outputSuccess(steps, options);
+  } else {
+    if (steps.length === 0) {
+      console.log(chalk21.dim("No step types found."));
+      return;
+    }
+    console.log(
+      `Found ${chalk21.cyan(steps.length)} step type${steps.length === 1 ? "" : "s"}:
+`
+    );
+    const rows = steps.map((s) => [
+      s.id,
+      s.name,
+      s.category,
+      s.isPrimitive ? chalk21.yellow("primitive") : ""
+    ]);
+    console.log(formatTable(["Type", "Name", "Category", ""], rows));
+  }
+}
+
+// src/commands/template/step/info.ts
+import chalk22 from "chalk";
+import ora21 from "ora";
+async function stepInfoCommand(stepType, options) {
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora21("Fetching step info...").start() : null;
+  const client = createConvexClient(convexConfig);
+  const result = await client.query("templates.stepInfo", {
+    stepId: stepType
+  });
+  spinner?.stop();
+  spinner?.clear();
+  if (!result.success) {
+    outputError(result.error ?? "Failed to get step info", options);
+    process.exit(1);
+  }
+  if (!result.data) {
+    outputError(`Step type "${stepType}" not found`, options);
+    process.exit(1);
+  }
+  const step2 = result.data;
+  if (options.json) {
+    outputSuccess(step2, options);
+  } else {
+    console.log(
+      formatKeyValue([
+        { key: "Type", value: step2.id },
+        { key: "Name", value: step2.name },
+        { key: "Category", value: step2.category },
+        { key: "Description", value: step2.description },
+        {
+          key: "Primitive",
+          value: step2.isPrimitive ? chalk22.yellow("yes") : "no"
+        }
+      ])
+    );
+    const visibleInputs = step2.inputs.filter((i) => !i.hidden);
+    if (visibleInputs.length > 0) {
+      console.log(`
+${chalk22.bold("Inputs")}:
+`);
+      const inputRows = visibleInputs.map((i) => [
+        i.key,
+        i.type,
+        i.required ? chalk22.green("yes") : chalk22.dim("no"),
+        i.description
+      ]);
+      console.log(
+        formatTable(["Key", "Type", "Required", "Description"], inputRows)
+      );
+    }
+    if (step2.outputs.length > 0) {
+      console.log(`
+${chalk22.bold("Outputs")}:
+`);
+      const outputRows = step2.outputs.map((o) => [
+        o.key,
+        o.type,
+        o.description
+      ]);
+      console.log(formatTable(["Key", "Type", "Description"], outputRows));
+    }
+  }
+}
+
+// src/commands/template/step/add.ts
+import chalk23 from "chalk";
+import ora22 from "ora";
+import crypto from "crypto";
+async function stepAddCommand(stepType, options) {
+  const templateId = options.template ?? getActiveTemplate();
+  if (!templateId) {
+    outputError(
+      "No template ID. Use --template <id> or set active template with 'template use <id>'.",
+      options
+    );
+    process.exit(1);
+  }
+  let config = {};
+  if (options.config) {
+    try {
+      config = JSON.parse(options.config);
+    } catch {
+      outputError("Invalid JSON in --config parameter", options);
+      process.exit(1);
+    }
+  }
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora22("Adding step...").start() : null;
+  const client = createConvexClient(convexConfig);
+  const getResult = await client.query("templates.byId", {
+    id: templateId
+  });
+  if (!getResult.success || !getResult.data) {
+    spinner?.stop();
+    spinner?.clear();
+    outputError(getResult.error ?? "Template not found", options);
+    process.exit(1);
+  }
+  const steps = (getResult.data.steps ?? []).map((s) => ({ ...s }));
+  const newId = crypto.randomUUID().slice(0, 8);
+  let insertAt;
+  if (options.at !== void 0) {
+    insertAt = Math.max(0, Math.min(options.at, steps.length));
+  } else if (options.after) {
+    const afterIndex = steps.findIndex((s) => s.id === options.after);
+    if (afterIndex === -1) {
+      spinner?.stop();
+      spinner?.clear();
+      outputError(`Step with id "${options.after}" not found`, options);
+      process.exit(1);
+    }
+    insertAt = afterIndex + 1;
+  } else {
+    insertAt = steps.length;
+  }
+  const newStep = {
+    id: newId,
+    stepId: stepType,
+    config,
+    order: insertAt
+  };
+  steps.splice(insertAt, 0, newStep);
+  for (let i = 0; i < steps.length; i++) {
+    const s = steps[i];
+    if (s) s.order = i;
+  }
+  const updateResult = await client.mutation("templates.update", {
+    id: templateId,
+    steps
+  });
+  spinner?.stop();
+  spinner?.clear();
+  if (!updateResult.success) {
+    outputError(updateResult.error ?? "Failed to update template", options);
+    process.exit(1);
+  }
+  if (options.json) {
+    outputSuccess(
+      { id: newId, stepId: stepType, order: insertAt, templateId },
+      options
+    );
+  } else {
+    console.log(formatSuccess(`Step added: ${stepType}`));
+    console.log(chalk23.dim(`  Step ID: ${newId}`));
+    console.log(chalk23.dim(`  Position: ${insertAt}`));
+  }
+}
+
+// src/commands/template/step/remove.ts
+import ora23 from "ora";
+async function stepRemoveCommand(stepInstanceId, options) {
+  const templateId = options.template ?? getActiveTemplate();
+  if (!templateId) {
+    outputError(
+      "No template ID. Use --template <id> or set active template with 'template use <id>'.",
+      options
+    );
+    process.exit(1);
+  }
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora23("Removing step...").start() : null;
+  const client = createConvexClient(convexConfig);
+  const getResult = await client.query("templates.byId", {
+    id: templateId
+  });
+  if (!getResult.success || !getResult.data) {
+    spinner?.stop();
+    spinner?.clear();
+    outputError(getResult.error ?? "Template not found", options);
+    process.exit(1);
+  }
+  const steps = getResult.data.steps ?? [];
+  const removeIndex = steps.findIndex((s) => s.id === stepInstanceId);
+  if (removeIndex === -1) {
+    spinner?.stop();
+    spinner?.clear();
+    outputError(`Step with id "${stepInstanceId}" not found in template`, options);
+    process.exit(1);
+  }
+  const removed = steps[removeIndex];
+  if (!removed) {
+    spinner?.stop();
+    spinner?.clear();
+    outputError(`Step at index ${removeIndex} not found`, options);
+    process.exit(1);
+  }
+  const newSteps = steps.filter((_, i) => i !== removeIndex);
+  for (let i = 0; i < newSteps.length; i++) {
+    const s = newSteps[i];
+    if (s) s.order = i;
+  }
+  const updateResult = await client.mutation("templates.update", {
+    id: templateId,
+    steps: newSteps
+  });
+  spinner?.stop();
+  spinner?.clear();
+  if (!updateResult.success) {
+    outputError(updateResult.error ?? "Failed to update template", options);
+    process.exit(1);
+  }
+  if (options.json) {
+    outputSuccess(
+      { removed: stepInstanceId, stepId: removed.stepId, templateId },
+      options
+    );
+  } else {
+    console.log(formatSuccess(`Removed step: ${removed.stepId} (${stepInstanceId})`));
+  }
+}
+
+// src/commands/template/step/update.ts
+import ora24 from "ora";
+async function stepUpdateCommand(stepInstanceId, options) {
+  const templateId = options.template ?? getActiveTemplate();
+  if (!templateId) {
+    outputError(
+      "No template ID. Use --template <id> or set active template with 'template use <id>'.",
+      options
+    );
+    process.exit(1);
+  }
+  if (!options.config) {
+    outputError("--config is required", options);
+    process.exit(1);
+  }
+  let configPatch;
+  try {
+    configPatch = JSON.parse(options.config);
+  } catch {
+    outputError("Invalid JSON in --config parameter", options);
+    process.exit(1);
+  }
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora24("Updating step...").start() : null;
+  const client = createConvexClient(convexConfig);
+  const getResult = await client.query("templates.byId", {
+    id: templateId
+  });
+  if (!getResult.success || !getResult.data) {
+    spinner?.stop();
+    spinner?.clear();
+    outputError(getResult.error ?? "Template not found", options);
+    process.exit(1);
+  }
+  const steps = (getResult.data.steps ?? []).map((s) => ({ ...s }));
+  const stepIndex = steps.findIndex((s) => s.id === stepInstanceId);
+  if (stepIndex === -1) {
+    spinner?.stop();
+    spinner?.clear();
+    outputError(`Step with id "${stepInstanceId}" not found in template`, options);
+    process.exit(1);
+  }
+  const targetStep = steps[stepIndex];
+  if (!targetStep) {
+    spinner?.stop();
+    spinner?.clear();
+    outputError(`Step at index ${stepIndex} not found`, options);
+    process.exit(1);
+  }
+  targetStep.config = {
+    ...targetStep.config,
+    ...configPatch
+  };
+  const updateResult = await client.mutation("templates.update", {
+    id: templateId,
+    steps
+  });
+  spinner?.stop();
+  spinner?.clear();
+  if (!updateResult.success) {
+    outputError(updateResult.error ?? "Failed to update template", options);
+    process.exit(1);
+  }
+  if (options.json) {
+    outputSuccess(
+      {
+        id: stepInstanceId,
+        stepId: targetStep.stepId,
+        config: targetStep.config,
+        templateId
+      },
+      options
+    );
+  } else {
+    console.log(
+      formatSuccess(
+        `Updated step: ${targetStep.stepId} (${stepInstanceId})`
+      )
+    );
+  }
+}
+
+// src/commands/template/model/list.ts
+import chalk24 from "chalk";
+import ora25 from "ora";
+async function modelListCommand(category, options) {
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora25("Fetching models...").start() : null;
+  const client = createConvexClient(convexConfig);
+  const result = await client.query("models.list", { category });
+  spinner?.stop();
+  spinner?.clear();
+  if (!result.success || !result.data) {
+    outputError(result.error ?? "Failed to list models", options);
+    process.exit(1);
+  }
+  const models = result.data;
+  if (options.json) {
+    outputSuccess(
+      models.map((m) => ({
+        modelId: m.modelId,
+        name: m.displayName ?? m.modelName,
+        provider: m.provider,
+        description: m.description
+      })),
+      options
+    );
+  } else {
+    if (models.length === 0) {
+      console.log(chalk24.dim(`No ${category} models found.`));
+      return;
+    }
+    console.log(
+      `Found ${chalk24.cyan(models.length)} ${category} model${models.length === 1 ? "" : "s"}:
+`
+    );
+    const rows = models.map((m) => [
+      m.modelId,
+      m.displayName ?? m.modelName,
+      m.provider
+    ]);
+    console.log(formatTable(["Model ID", "Name", "Provider"], rows));
+  }
+}
+
+// src/commands/template/model/schema.ts
+import chalk25 from "chalk";
+import ora26 from "ora";
+async function modelSchemaCommand(modelId, options) {
+  const showSpinner = !options.json && process.stdout.isTTY;
+  const spinner = showSpinner ? ora26("Fetching model schema...").start() : null;
+  const client = createConvexClient(convexConfig);
+  const result = await client.query("models.byModelId", {
+    modelId
+  });
+  spinner?.stop();
+  spinner?.clear();
+  if (!result.success) {
+    outputError(result.error ?? "Failed to get model", options);
+    process.exit(1);
+  }
+  if (!result.data) {
+    outputError(`Model "${modelId}" not found`, options);
+    process.exit(1);
+  }
+  const model2 = result.data;
+  if (options.json) {
+    outputSuccess(
+      {
+        modelId: model2.modelId,
+        name: model2.displayName ?? model2.modelName,
+        provider: model2.provider,
+        category: model2.category,
+        description: model2.description,
+        inputSchema: model2.inputSchema
+      },
+      options
+    );
+  } else {
+    console.log(
+      formatKeyValue([
+        { key: "Model ID", value: model2.modelId },
+        { key: "Name", value: model2.displayName ?? model2.modelName },
+        { key: "Provider", value: model2.provider },
+        { key: "Category", value: model2.category },
+        {
+          key: "Description",
+          value: model2.description ?? chalk25.dim("None")
+        }
+      ])
+    );
+    const schema = model2.inputSchema;
+    if (!schema?.properties) {
+      console.log(chalk25.dim("\nNo input schema available."));
+      return;
+    }
+    const required = new Set(schema.required ?? []);
+    const props = schema.properties;
+    console.log(`
+${chalk25.bold("Input Parameters")}:
+`);
+    const rows = Object.entries(props).map(([key, prop]) => [
+      key,
+      prop.type ?? "unknown",
+      required.has(key) ? chalk25.green("yes") : chalk25.dim("no"),
+      formatDefault(prop.default),
+      formatConstraints(prop)
+    ]);
+    console.log(
+      formatTable(
+        ["Parameter", "Type", "Required", "Default", "Constraints"],
+        rows
+      )
+    );
+    const withDescriptions = Object.entries(props).filter(
+      ([, p]) => p.description
+    );
+    if (withDescriptions.length > 0) {
+      console.log(`
+${chalk25.bold("Parameter Details")}:
+`);
+      for (const [key, prop] of withDescriptions) {
+        console.log(`  ${chalk25.cyan(key)}: ${prop.description}`);
+        if (prop.enum) {
+          console.log(
+            `    Values: ${prop.enum.map((v) => chalk25.green(String(v))).join(", ")}`
+          );
+        }
+      }
+    }
+  }
+}
+function formatDefault(value) {
+  if (value === void 0 || value === null) return chalk25.dim("\u2014");
+  if (typeof value === "object") return JSON.stringify(value);
+  return String(value);
+}
+function formatConstraints(prop) {
+  const parts = [];
+  if (prop.enum) {
+    const enumStr = prop.enum.map(String).join("|");
+    parts.push(enumStr.length > 40 ? enumStr.substring(0, 37) + "..." : enumStr);
+  }
+  if (prop.minimum !== void 0) parts.push(`min:${prop.minimum}`);
+  if (prop.maximum !== void 0) parts.push(`max:${prop.maximum}`);
+  return parts.length > 0 ? parts.join(", ") : chalk25.dim("\u2014");
+}
+
+// src/index.ts
+var program = new Command();
+var require2 = createRequire(import.meta.url);
+var packageJson = require2("../package.json");
+program.name("program").description("CLI for the Program video creation platform").version(packageJson.version);
+var auth = program.command("auth").description("Authentication commands");
+auth.command("login").description("Authenticate with the Program platform").option("--json", "Output as JSON").action(async (options) => {
+  await loginCommand(options);
+});
+auth.command("logout").description("Log out from the Program platform").option("--json", "Output as JSON").action((options) => {
+  logoutCommand(options);
+});
+auth.command("status").description("Check authentication status").option("--json", "Output as JSON").action((options) => {
+  statusCommand(options);
+});
+var project = program.command("project").description("Project management commands");
+project.command("create").description("Create a new project").option("--title <title>", "Project title").option("--description <description>", "Project description").option("--json", "Output as JSON").action(async (options) => {
+  await createCommand(options);
+});
+project.command("list").description("List projects").option("--limit <limit>", "Maximum number of projects to return", parseInt).option("--json", "Output as JSON").action(async (options) => {
+  await listCommand(options);
+});
+project.command("get <id>").description("Get project details including composition").option("--json", "Output as JSON").action(async (id, options) => {
+  await getCommand(id, options);
+});
+var workflow = program.command("workflow").description("Workflow template commands (use 'template' for full management)");
+workflow.command("list").description("List available workflow templates").option("--limit <limit>", "Maximum number of templates to return", parseInt).option("--public-only", "Only show public templates").option("--json", "Output as JSON").action(async (options) => {
+  await listCommand2(options);
+});
+workflow.command("run <templateId>").description("Execute a workflow template").option("--project <projectId>", "Project ID to associate with execution").option("--input <json>", "JSON input for the workflow").option("--json", "Output as JSON").action(async (templateId, options) => {
+  await runCommand(templateId, options);
+});
+workflow.command("status <executionId>").description("Check workflow execution status").option("--watch", "Continuously poll for status updates").option("--interval <ms>", "Poll interval in milliseconds", parseInt).option("--json", "Output as JSON").action(async (executionId, options) => {
+  await statusCommand2(executionId, options);
+});
+var template = program.command("template").description("Template management commands");
+template.command("list").description("List templates").option("--public-only", "Only show public templates").option("--json", "Output as JSON").action(async (options) => {
+  await listCommand5(options);
+});
+template.command("get [id]").description("Get template details (uses active template if no ID)").option("--json", "Output as JSON").action(async (id, options) => {
+  await getCommand2(id, options);
+});
+template.command("create").description("Create a new template (auto-sets as active)").requiredOption("--name <name>", "Template name").option("--description <description>", "Template description").option("--public", "Make template public").option("--json", "Output as JSON").action(async (options) => {
+  await createCommand2(options);
+});
+template.command("update [id]").description("Update template metadata (uses active template if no ID)").option("--name <name>", "New template name").option("--description <description>", "New template description").option("--public", "Make template public").option("--json", "Output as JSON").action(async (id, options) => {
+  await updateCommand(id, options);
+});
+template.command("remove [id]").description("Delete a template (uses active template if no ID)").option("--force", "Skip confirmation prompt").option("--json", "Output as JSON").action(async (id, options) => {
+  await removeCommand(id, options);
+});
+template.command("run [id]").description("Execute a template (uses active template if no ID)").option("--project <projectId>", "Project ID to associate with execution").option("--input <json>", "JSON input for the workflow").option("--json", "Output as JSON").action(async (id, options) => {
+  await runCommand2(id, options);
+});
+template.command("status <executionId>").description("Check execution status").option("--watch", "Continuously poll for status updates").option("--interval <ms>", "Poll interval in milliseconds", parseInt).option("--json", "Output as JSON").action(async (executionId, options) => {
+  await statusCommand3(executionId, options);
+});
+template.command("use <id>").description("Set the active template context").option("--json", "Output as JSON").action(async (id, options) => {
+  await useCommand(id, options);
+});
+var step = template.command("step").description("Manage template steps and discover step types");
+step.command("list").description("List available step types").option("--category <category>", "Filter by category").option("--json", "Output as JSON").action(async (options) => {
+  await stepListCommand(options);
+});
+step.command("info <stepType>").description("Show step type details (inputs, outputs)").option("--json", "Output as JSON").action(async (stepType, options) => {
+  await stepInfoCommand(stepType, options);
+});
+step.command("add <stepType>").description("Add a step to the active template").option("--config <json>", "Step configuration as JSON").option("--at <position>", "Insert at position (0-indexed)", parseInt).option("--after <id>", "Insert after step with this ID").option("--template <id>", "Template ID (overrides active template)").option("--json", "Output as JSON").action(async (stepType, options) => {
+  await stepAddCommand(stepType, options);
+});
+step.command("remove <id>").description("Remove a step by its instance ID").option("--template <id>", "Template ID (overrides active template)").option("--json", "Output as JSON").action(async (id, options) => {
+  await stepRemoveCommand(id, options);
+});
+step.command("update <id>").description("Update a step's config by its instance ID").option("--config <json>", "Config to merge as JSON").option("--template <id>", "Template ID (overrides active template)").option("--json", "Output as JSON").action(async (id, options) => {
+  await stepUpdateCommand(id, options);
+});
+var model = template.command("model").description("Browse models and schemas");
+model.command("list <category>").description("List models for a category (image, video, speech, text)").option("--json", "Output as JSON").action(async (category, options) => {
+  await modelListCommand(category, options);
+});
+model.command("schema <modelId>").description("Show full input schema for a model").option("--json", "Output as JSON").action(async (modelId, options) => {
+  await modelSchemaCommand(modelId, options);
 });
 var tool = program.command("tool").description("Execute agent tools directly");
 tool.addHelpText(