@program-video/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1322 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/auth/login.ts
+import chalk2 from "chalk";
+import ora from "ora";
+
+// src/lib/auth/credentials.ts
+import Conf from "conf";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+var CREDENTIALS_DIR = path.join(os.homedir(), ".program");
+var CREDENTIALS_FILE = path.join(CREDENTIALS_DIR, "credentials.json");
+function ensureCredentialsDir() {
+  if (!fs.existsSync(CREDENTIALS_DIR)) {
+    fs.mkdirSync(CREDENTIALS_DIR, { mode: 448, recursive: true });
+  }
+}
+var store = new Conf({
+  projectName: "program-cli",
+  cwd: CREDENTIALS_DIR,
+  configName: "credentials",
+  fileExtension: "json",
+  defaults: {
+    credentials: null
+  }
+});
+function saveCredentials(credentials) {
+  ensureCredentialsDir();
+  store.set("credentials", credentials);
+  try {
+    fs.chmodSync(CREDENTIALS_FILE, 384);
+  } catch {
+  }
+}
+function getCredentials() {
+  return store.get("credentials");
+}
+function clearCredentials() {
+  store.delete("credentials");
+}
+function isAuthenticated() {
+  const creds = getCredentials();
+  if (!creds) return false;
+  const now = Date.now();
+  const expiresAt = creds.expiresAt * 1e3;
+  const bufferMs = 5 * 60 * 1e3;
+  return now < expiresAt - bufferMs;
+}
+function needsRefresh() {
+  const creds = getCredentials();
+  if (!creds) return false;
+  const now = Date.now();
+  const expiresAt = creds.expiresAt * 1e3;
+  const bufferMs = 5 * 60 * 1e3;
+  return now >= expiresAt - bufferMs && now < expiresAt;
+}
+
+// src/lib/auth/device.ts
+var CLIENT_ID = "program-cli";
+var SCOPES = ["openid", "profile", "email", "offline_access"];
+async function requestDeviceCode(config) {
+  const url = new URL("/api/auth/device/code", config.baseUrl);
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      client_id: CLIENT_ID,
+      scope: SCOPES.join(" ")
+    })
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`Failed to get device code: ${response.status} ${errorText}`);
+  }
+  return response.json();
+}
+async function pollForToken(config, deviceCode) {
+  const url = new URL("/api/auth/device/token", config.baseUrl);
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+      device_code: deviceCode,
+      client_id: CLIENT_ID
+    })
+  });
+  const data = await response.json();
+  if (!response.ok) {
+    if ("error" in data) {
+      return data;
+    }
+    throw new Error(`Token request failed: ${response.status}`);
+  }
+  return data;
+}
+async function getUserInfo(config, accessToken) {
+  const sessionUrl = new URL("/api/auth/get-session", config.baseUrl);
+  const response = await fetch(sessionUrl.toString(), {
+    headers: {
+      Authorization: `Bearer ${accessToken}`
+    }
+  });
+  if (!response.ok) {
+    const tokenUrl = new URL("/api/auth/token", config.baseUrl);
+    const tokenResponse = await fetch(tokenUrl.toString(), {
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+    if (!tokenResponse.ok) {
+      throw new Error(`Failed to get user info: ${response.status}`);
+    }
+    const tokenData = await tokenResponse.json();
+    if (!tokenData.user?.id || !tokenData.user.email) {
+      throw new Error("Invalid token response: missing user info");
+    }
+    return {
+      id: tokenData.user.id,
+      email: tokenData.user.email,
+      name: tokenData.user.name ?? tokenData.user.email,
+      organizationId: tokenData.session?.activeOrganizationId
+    };
+  }
+  const data = await response.json();
+  if (!data.user?.id || !data.user.email) {
+    throw new Error("Invalid session response: missing user info");
+  }
+  return {
+    id: data.user.id,
+    email: data.user.email,
+    name: data.user.name ?? data.user.email,
+    organizationId: data.session?.activeOrganizationId
+  };
+}
+async function startDeviceAuth(config) {
+  const deviceCode = await requestDeviceCode(config);
+  return {
+    userCode: deviceCode.user_code,
+    verificationUrl: deviceCode.verification_uri,
+    verificationUrlComplete: deviceCode.verification_uri_complete,
+    expiresIn: deviceCode.expires_in,
+    interval: deviceCode.interval,
+    pollForCompletion: async () => {
+      return pollUntilComplete(config, deviceCode);
+    }
+  };
+}
+async function pollUntilComplete(config, deviceCode) {
+  const startTime = Date.now();
+  const expiresAt = startTime + deviceCode.expires_in * 1e3;
+  let interval = deviceCode.interval * 1e3;
+  while (Date.now() < expiresAt) {
+    await new Promise((resolve) => setTimeout(resolve, interval));
+    const result = await pollForToken(config, deviceCode.device_code);
+    if ("error" in result) {
+      switch (result.error) {
+        case "authorization_pending":
+          continue;
+        case "slow_down":
+          interval += 5e3;
+          continue;
+        case "expired_token":
+          throw new Error("Device code expired. Please start a new login.");
+        case "access_denied":
+          throw new Error("Access denied. You denied the authorization request.");
+        default:
+          throw new Error(
+            result.error_description ?? `Authorization failed: ${result.error}`
+          );
+      }
+    }
+    const tokens = result;
+    const userInfo = await getUserInfo(config, tokens.access_token);
+    const expiresIn = tokens.expires_in ?? 3600;
+    const expiresAtTimestamp = Math.floor(Date.now() / 1e3) + expiresIn;
+    const credentials = {
+      accessToken: tokens.access_token,
+      refreshToken: tokens.refresh_token ?? "",
+      expiresAt: expiresAtTimestamp,
+      userId: userInfo.id,
+      organizationId: userInfo.organizationId ?? "",
+      email: userInfo.email
+    };
+    saveCredentials(credentials);
+    return credentials;
+  }
+  throw new Error("Device code expired. Please start a new login.");
+}
+
+// src/lib/config.ts
+function getEnvOrDefault(key, defaultValue) {
+  return process.env[key] ?? defaultValue;
+}
+var BASE_URL = getEnvOrDefault(
+  "BASE_URL",
+  "https://program.video"
+);
+function getConvexUrl() {
+  const override = process.env.PROGRAM_CONVEX_URL;
+  if (override) return override;
+  const convexUrl = process.env.NEXT_PUBLIC_CONVEX_URL;
+  if (convexUrl) return convexUrl;
+  return "https://mild-hyena-697.convex.cloud";
+}
+var CONVEX_URL = getConvexUrl();
+var oauthConfig = {
+  baseUrl: BASE_URL
+};
+var convexConfig = {
+  convexUrl: CONVEX_URL,
+  oauthConfig
+};
+
+// src/lib/output.ts
+import chalk from "chalk";
+function outputSuccess(data, options = {}) {
+  if (options.json) {
+    const result = { success: true, data };
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.log(data);
+  }
+}
+function outputError(error, options = {}) {
+  if (options.json) {
+    const result = { success: false, error };
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    console.error(chalk.red("Error:"), error);
+  }
+}
+function formatTable(headers, rows, options = {}) {
+  const indent = " ".repeat(options.indent ?? 0);
+  const widths = headers.map((h, i) => {
+    const maxRow = Math.max(...rows.map((r) => (r[i] ?? "").length));
+    return Math.max(h.length, maxRow);
+  });
+  const headerLine = headers.map((h, i) => chalk.bold(h.padEnd(widths[i] ?? 0))).join("  ");
+  const separator = widths.map((w) => "-".repeat(w)).join("  ");
+  const formattedRows = rows.map(
+    (row) => row.map((cell, i) => (cell || "").padEnd(widths[i] ?? 0)).join("  ")
+  );
+  return [indent + headerLine, indent + separator, ...formattedRows.map((r) => indent + r)].join(
+    "\n"
+  );
+}
+function formatKeyValue(items, options = {}) {
+  const indent = " ".repeat(options.indent ?? 0);
+  const maxKeyLength = Math.max(...items.map((item) => item.key.length));
+  return items.map(
+    (item) => indent + chalk.dim(item.key.padEnd(maxKeyLength) + ":") + " " + item.value
+  ).join("\n");
+}
+function formatSuccess(message2) {
+  return chalk.green("\u2713") + " " + message2;
+}
+function formatWarning(message2) {
+  return chalk.yellow("\u26A0") + " " + message2;
+}
+
+// src/commands/auth/login.ts
+function formatUserCode(code) {
+  if (code.length === 8) {
+    return `${code.slice(0, 4)}-${code.slice(4)}`;
+  }
+  return code;
+}
+async function loginCommand(options) {
+  const spinner = ora("Requesting device code...").start();
+  try {
+    const deviceAuth = await startDeviceAuth(oauthConfig);
+    spinner.stop();
+    console.log();
+    console.log(chalk2.bold("  Sign in to Program"));
+    console.log();
+    console.log(`  Visit: ${chalk2.cyan(deviceAuth.verificationUrl)}`);
+    console.log();
+    console.log(`  Enter code: ${chalk2.bold.yellow(formatUserCode(deviceAuth.userCode))}`);
+    console.log();
+    if (deviceAuth.verificationUrlComplete) {
+      console.log(chalk2.dim(`  Or open: ${deviceAuth.verificationUrlComplete}`));
+      console.log();
+    }
+    const waitingSpinner = ora("Waiting for authorization...").start();
+    const credentials = await deviceAuth.pollForCompletion();
+    waitingSpinner.stop();
+    if (options.json) {
+      outputSuccess(
+        {
+          authenticated: true,
+          email: credentials.email,
+          userId: credentials.userId,
+          organizationId: credentials.organizationId
+        },
+        options
+      );
+    } else {
+      console.log(formatSuccess(`Authenticated as ${chalk2.cyan(credentials.email)}`));
+      if (credentials.organizationId) {
+        console.log(chalk2.dim(`  Organization: ${credentials.organizationId}`));
+      }
+    }
+  } catch (error) {
+    const message2 = error instanceof Error ? error.message : "Authentication failed";
+    outputError(message2, options);
+    process.exit(1);
+  }
+}
+
+// src/commands/auth/logout.ts
+function logoutCommand(options) {
+  const credentials = getCredentials();
+  if (!credentials) {
+    if (options.json) {
+      outputSuccess({ loggedOut: true, wasAuthenticated: false }, options);
+    } else {
+      console.log("Not currently logged in.");
+    }
+    return;
+  }
+  const email = credentials.email;
+  clearCredentials();
+  if (options.json) {
+    outputSuccess({ loggedOut: true, wasAuthenticated: true, email }, options);
+  } else {
+    console.log(formatSuccess(`Logged out from ${email}`));
+  }
+}
+
+// src/commands/auth/status.ts
+import chalk3 from "chalk";
+function statusCommand(options) {
+  const credentials = getCredentials();
+  if (!credentials) {
+    if (options.json) {
+      outputSuccess({ authenticated: false }, options);
+    } else {
+      console.log("Not logged in. Run 'program auth login' to authenticate.");
+    }
+    return;
+  }
+  const authenticated = isAuthenticated();
+  const expiresAt = credentials.expiresAt;
+  const now = Math.floor(Date.now() / 1e3);
+  const expiresIn = expiresAt - now;
+  if (options.json) {
+    outputSuccess(
+      {
+        authenticated,
+        user: credentials.email,
+        userId: credentials.userId,
+        organizationId: credentials.organizationId,
+        expiresAt,
+        expiresIn,
+        needsRefresh: needsRefresh()
+      },
+      options
+    );
+  } else {
+    if (!authenticated) {
+      console.log(formatWarning("Token expired. Run 'program auth login' to re-authenticate."));
+      return;
+    }
+    console.log(formatSuccess("Logged in"));
+    console.log();
+    console.log(
+      formatKeyValue([
+        { key: "Email", value: credentials.email },
+        { key: "User ID", value: credentials.userId },
+        { key: "Organization", value: credentials.organizationId || chalk3.dim("(none)") },
+        { key: "Token expires", value: formatExpiresIn(expiresIn) }
+      ])
+    );
+  }
+}
+function formatExpiresIn(seconds) {
+  if (seconds <= 0) {
+    return chalk3.red("expired");
+  }
+  if (seconds < 60) {
+    return chalk3.yellow(`in ${seconds} seconds`);
+  }
+  if (seconds < 3600) {
+    const minutes2 = Math.floor(seconds / 60);
+    return chalk3.green(`in ${minutes2} minute${minutes2 === 1 ? "" : "s"}`);
+  }
+  const hours = Math.floor(seconds / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  return chalk3.green(`in ${hours}h ${minutes}m`);
+}
+
+// src/commands/project/create.ts
+import chalk4 from "chalk";
+import ora2 from "ora";
+
+// src/lib/auth/oauth.ts
+import open from "open";
+
+// src/lib/auth/pkce.ts
+import * as crypto from "crypto";
+
+// src/lib/auth/callback-server.ts
+import * as http from "http";
+import { URL as URL2 } from "url";
+
+// src/lib/auth/oauth.ts
+var CALLBACK_PORT = 8976;
+var REDIRECT_URI = `http://localhost:${CALLBACK_PORT}/callback`;
+var CLIENT_ID2 = "program-cli";
+async function refreshAccessToken(config) {
+  const creds = getCredentials();
+  if (!creds?.refreshToken) {
+    return null;
+  }
+  const tokenUrl = new URL("/api/auth/oauth2/token", config.baseUrl);
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: CLIENT_ID2,
+    refresh_token: creds.refreshToken
+  });
+  const response = await fetch(tokenUrl.toString(), {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: body.toString()
+  });
+  if (!response.ok) {
+    return null;
+  }
+  const tokens = await response.json();
+  const expiresAt = Math.floor(Date.now() / 1e3) + tokens.expires_in;
+  const newCredentials = {
+    ...creds,
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token ?? creds.refreshToken,
+    expiresAt
+  };
+  saveCredentials(newCredentials);
+  return newCredentials;
+}
+async function ensureValidToken(config) {
+  const creds = getCredentials();
+  if (!creds) {
+    return null;
+  }
+  const now = Date.now();
+  const expiresAt = creds.expiresAt * 1e3;
+  const bufferMs = 5 * 60 * 1e3;
+  if (now < expiresAt - bufferMs) {
+    return creds.accessToken;
+  }
+  const refreshed = await refreshAccessToken(config);
+  return refreshed?.accessToken ?? null;
+}
+
+// src/lib/convex.ts
+function createConvexClient(config) {
+  const { convexUrl } = config;
+  const gatewayUrl = convexUrl.replace(".convex.cloud", ".convex.site");
+  async function query(functionPath, args = {}) {
+    return callGateway(functionPath, args);
+  }
+  async function mutation(functionPath, args = {}) {
+    return callGateway(functionPath, args);
+  }
+  async function action(functionPath, args = {}) {
+    return callGateway(functionPath, args);
+  }
+  async function callGateway(functionPath, args) {
+    const accessToken = await ensureValidToken(config.oauthConfig);
+    if (!accessToken) {
+      return {
+        success: false,
+        error: "Not authenticated. Run 'program auth login' first."
+      };
+    }
+    const url = new URL("/cli", gatewayUrl);
+    try {
+      const response = await fetch(url.toString(), {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${accessToken}`
+        },
+        body: JSON.stringify({
+          fn: functionPath,
+          params: args
+        })
+      });
+      const result = await response.json();
+      if (!response.ok || !result.success) {
+        return {
+          success: false,
+          error: result.error ?? `Gateway error: ${response.status}`
+        };
+      }
+      return { success: true, data: result.data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  function getAuth() {
+    return getCredentials();
+  }
+  return {
+    query,
+    mutation,
+    action,
+    getAuth
+  };
+}
+
+// src/commands/project/create.ts
+async function createCommand(options) {
+  const spinner = options.json ? null : ora2("Creating project...").start();
+  const client = createConvexClient(convexConfig);
+  const result = await client.mutation("projects.create", {
+    title: options.title,
+    description: options.description
+  });
+  spinner?.stop();
+  if (!result.success || !result.data) {
+    outputError(result.error ?? "Failed to create project", options);
+    process.exit(1);
+  }
+  const projectData = {
+    id: result.data,
+    title: options.title ?? "Untitled Project"
+  };
+  if (options.json) {
+    outputSuccess(projectData, options);
+  } else {
+    console.log(formatSuccess(`Created project ${chalk4.cyan(projectData.title)}`));
+    console.log(chalk4.dim(`  ID: ${projectData.id}`));
+  }
+}
+
+// src/commands/project/get.ts
+import chalk5 from "chalk";
+import ora3 from "ora";
+async function getCommand(projectId, options) {
+  const spinner = options.json ? null : ora3("Fetching project...").start();
+  const client = createConvexClient(convexConfig);
+  const result = await client.query("projects.byId", {
+    id: projectId
+  });
+  spinner?.stop();
+  if (!result.success || !result.data) {
+    outputError(result.error ?? "Failed to get project", options);
+    process.exit(1);
+  }
+  const project2 = result.data;
+  if (options.json) {
+    outputSuccess(project2, options);
+  } else {
+    console.log(chalk5.bold(project2.title || "Untitled Project"));
+    if (project2.description) {
+      console.log(chalk5.dim(project2.description));
+    }
+    console.log();
+    console.log(
+      formatKeyValue([
+        { key: "ID", value: project2._id },
+        { key: "Created", value: new Date(project2.createdAt).toLocaleString() },
+        { key: "Updated", value: new Date(project2.updatedAt).toLocaleString() }
+      ])
+    );
+    if (project2.latestVersion) {
+      console.log(chalk5.bold("\nVersion"));
+      console.log(
+        formatKeyValue([
+          { key: "Version", value: String(project2.latestVersion.version) },
+          { key: "Composition ID", value: project2.latestVersion.compositionId }
+        ])
+      );
+    } else {
+      console.log(chalk5.dim("\nNo versions yet"));
+    }
+    if (project2.composition) {
+      console.log(chalk5.bold("\nComposition"));
+      console.log(
+        formatKeyValue([
+          { key: "Title", value: project2.composition.title },
+          { key: "Resolution", value: `${project2.composition.width}x${project2.composition.height}` },
+          { key: "FPS", value: String(project2.composition.fps) },
+          { key: "Duration", value: `${(project2.composition.duration / 1e3).toFixed(1)}s` },
+          { key: "Scenes", value: String(project2.composition.sceneCount) }
+        ])
+      );
+      if (project2.composition.sceneCount > 0 && Array.isArray(project2.composition.scenes)) {
+        console.log(chalk5.bold("\nScenes"));
+        for (const scene of project2.composition.scenes) {
+          console.log(chalk5.dim(`  - ${scene.type} (${(scene.duration / 1e3).toFixed(1)}s)`));
+        }
+      }
+    } else {
+      console.log(chalk5.dim("\nNo composition yet"));
+    }
+  }
+}
+
+// src/commands/project/list.ts
+import chalk6 from "chalk";
+import ora4 from "ora";
+async function listCommand(options) {
+  const spinner = options.json ? null : ora4("Fetching projects...").start();
+  const client = createConvexClient(convexConfig);
+  const result = await client.query("projects.list", {
+    limit: options.limit
+  });
+  spinner?.stop();
+  if (!result.success || !result.data) {
+    outputError(result.error ?? "Failed to list projects", options);
+    process.exit(1);
+  }
+  const projects = result.data.items;
+  if (options.json) {
+    outputSuccess(projects, options);
+  } else {
+    if (projects.length === 0) {
+      console.log(chalk6.dim("No projects found. Create one with 'program project create'"));
+      return;
+    }
+    console.log(`Found ${chalk6.cyan(projects.length)} project${projects.length === 1 ? "" : "s"}:
+`);
+    const rows = projects.map((p) => [
+      p._id,
+      p.title || chalk6.dim("Untitled"),
+      formatDate(p.createdAt)
+    ]);
+    console.log(formatTable(["ID", "Title", "Created"], rows));
+  }
+}
+function formatDate(timestamp) {
+  const date = new Date(timestamp);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffDays = Math.floor(diffMs / (1e3 * 60 * 60 * 24));
+  if (diffDays === 0) {
+    return "today";
+  } else if (diffDays === 1) {
+    return "yesterday";
+  } else if (diffDays < 7) {
+    return `${diffDays} days ago`;
+  } else {
+    return date.toLocaleDateString();
+  }
+}
+
+// src/commands/workflow/list.ts
+import chalk7 from "chalk";
+import ora5 from "ora";
+async function listCommand2(options) {
+  const spinner = options.json ? null : ora5("Fetching workflow templates...").start();
+  const client = createConvexClient(convexConfig);
+  const result = await client.query("workflows.listTemplates", {
+    category: options.publicOnly ? "public" : void 0
+  });
+  spinner?.stop();
+  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
+      })),
+      options
+    );
+  } else {
+    if (templates.length === 0) {
+      console.log(chalk7.dim("No workflow templates found."));
+      return;
+    }
+    console.log(`Found ${chalk7.cyan(templates.length)} template${templates.length === 1 ? "" : "s"}:
+`);
+    const rows = templates.map((t) => [
+      t._id,
+      t.name,
+      t.description?.substring(0, 40) ?? chalk7.dim("No description"),
+      t.public ? chalk7.green("public") : chalk7.dim("private")
+    ]);
+    console.log(formatTable(["ID", "Name", "Description", "Visibility"], rows));
+  }
+}
+
+// src/commands/workflow/run.ts
+import chalk8 from "chalk";
+import ora6 from "ora";
+async function runCommand(templateId, options) {
+  const spinner = options.json ? null : ora6("Starting workflow execution...").start();
+  let input;
+  if (options.input) {
+    try {
+      input = JSON.parse(options.input);
+    } catch {
+      spinner?.stop();
+      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();
+  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(chalk8.dim(`  Execution ID: ${executionId}`));
+    console.log(chalk8.dim(`  Check status with: program workflow status ${executionId}`));
+  }
+}
+
+// src/commands/workflow/status.ts
+import chalk9 from "chalk";
+import ora7 from "ora";
+async function statusCommand2(executionId, options) {
+  const client = createConvexClient(convexConfig);
+  const pollInterval = options.interval ?? 2e3;
+  if (options.watch) {
+    await watchStatus(client, executionId, pollInterval, options);
+  } else {
+    await getStatusOnce(client, executionId, options);
+  }
+}
+async function getStatusOnce(client, executionId, options) {
+  const spinner = options.json ? null : ora7("Fetching execution status...").start();
+  const result = await client.query("workflows.status", {
+    executionId
+  });
+  spinner?.stop();
+  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 {
+    printStatus(status);
+  }
+}
+async function watchStatus(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(chalk9.dim(`Watching execution ${executionId}...
+`));
+        printStatus(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 printStatus(status) {
+  const statusColor = getStatusColor(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(chalk9.dim("\nStep progress:"));
+    for (const node of status.nodeStatuses) {
+      const nodeColor = getStatusColor(node.status);
+      console.log(`  ${nodeColor(getStatusIcon(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 getStatusColor(status) {
+  switch (status) {
+    case "success":
+      return chalk9.green;
+    case "error":
+      return chalk9.red;
+    case "cancelled":
+      return chalk9.yellow;
+    case "running":
+      return chalk9.blue;
+    case "pending":
+    default:
+      return chalk9.dim;
+  }
+}
+function getStatusIcon(status) {
+  switch (status) {
+    case "success":
+      return "\u2713";
+    case "error":
+      return "\u2715";
+    case "running":
+      return "\u25CF";
+    case "pending":
+    default:
+      return "\u25CB";
+  }
+}
+
+// src/commands/tool/execute.ts
+import chalk10 from "chalk";
+import ora8 from "ora";
+
+// src/lib/agent-detect.ts
+function detectAgentSource() {
+  if (process.env.CLAUDECODE === "1") {
+    return "claude-code";
+  }
+  return void 0;
+}
+
+// src/commands/tool/execute.ts
+async function executeCommand(toolName, options) {
+  const spinner = options.json ? null : ora8(`Executing ${toolName}...`).start();
+  const accessToken = await ensureValidToken(oauthConfig);
+  if (!accessToken) {
+    spinner?.stop();
+    outputError("Not authenticated. Run 'program auth login' first.", options);
+    process.exit(1);
+  }
+  let params = {};
+  if (options.params) {
+    try {
+      params = JSON.parse(options.params);
+    } catch {
+      spinner?.stop();
+      outputError("Invalid JSON in --params", options);
+      process.exit(1);
+    }
+  }
+  const source = detectAgentSource();
+  try {
+    const response = await fetch(`${BASE_URL}/api/cli/tool`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`
+      },
+      body: JSON.stringify({
+        projectId: options.project,
+        tool: toolName,
+        params,
+        source
+      })
+    });
+    const result = await response.json();
+    spinner?.stop();
+    if (!response.ok || !result.success) {
+      outputError(result.error ?? `Tool execution failed: ${response.status}`, options);
+      process.exit(1);
+    }
+    if (options.json) {
+      outputSuccess(result.data, options);
+    } else {
+      console.log(chalk10.green(`\u2713 ${toolName} executed successfully`));
+      if (result.compositionId) {
+        console.log(chalk10.dim(`  Composition: ${result.compositionId}`));
+      }
+      console.log();
+      console.log(JSON.stringify(result.data, null, 2));
+    }
+  } catch (error) {
+    spinner?.stop();
+    outputError(error instanceof Error ? error.message : "Request failed", options);
+    process.exit(1);
+  }
+}
+
+// src/commands/tool/list.ts
+import chalk11 from "chalk";
+import ora9 from "ora";
+async function listCommand3(options) {
+  const spinner = options.json ? null : ora9("Fetching available tools...").start();
+  try {
+    const response = await fetch(`${BASE_URL}/api/cli/tool`, {
+      method: "GET"
+    });
+    const result = await response.json();
+    spinner?.stop();
+    if (!response.ok || !result.success) {
+      outputError(result.error ?? "Failed to list tools", options);
+      process.exit(1);
+    }
+    const tools = result.tools ?? [];
+    if (options.json) {
+      outputSuccess(tools, options);
+    } else {
+      console.log(chalk11.bold(`Available Tools (${tools.length}):
+`));
+      for (const tool2 of tools) {
+        console.log(chalk11.cyan(`  ${tool2.name}`));
+        console.log(chalk11.dim(`    ${tool2.description}`));
+        if (tool2.inputs.length > 0) {
+          console.log(chalk11.dim(`    Inputs: ${tool2.inputs.join(", ")}`));
+        }
+        console.log();
+      }
+      console.log(chalk11.dim("Usage: program tool exec <toolName> --project <id> --params '{...}'"));
+    }
+  } catch (error) {
+    spinner?.stop();
+    outputError(error instanceof Error ? error.message : "Request failed", options);
+    process.exit(1);
+  }
+}
+
+// src/commands/message/send.ts
+import chalk12 from "chalk";
+import ora10 from "ora";
+async function sendCommand(text, options) {
+  const spinner = options.json ? null : ora10("Sending message...").start();
+  const accessToken = await ensureValidToken(oauthConfig);
+  if (!accessToken) {
+    spinner?.stop();
+    outputError("Not authenticated. Run 'program auth login' first.", options);
+    process.exit(1);
+  }
+  const role = options.role ?? "assistant";
+  const source = detectAgentSource();
+  try {
+    const response = await fetch(`${BASE_URL}/api/cli/message`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${accessToken}`
+      },
+      body: JSON.stringify({
+        projectId: options.project,
+        role,
+        text,
+        source
+      })
+    });
+    const result = await response.json();
+    spinner?.stop();
+    if (!response.ok || !result.success) {
+      outputError(result.error ?? `Failed to send message: ${response.status}`, options);
+      process.exit(1);
+    }
+    if (options.json) {
+      outputSuccess({ messageId: result.messageId, role, text }, options);
+    } else {
+      console.log(chalk12.green(`\u2713 Message sent as ${role}`));
+      if (result.messageId) {
+        console.log(chalk12.dim(`  Message ID: ${result.messageId}`));
+      }
+    }
+  } catch (error) {
+    spinner?.stop();
+    outputError(error instanceof Error ? error.message : "Request failed", options);
+    process.exit(1);
+  }
+}
+
+// src/commands/message/list.ts
+import chalk13 from "chalk";
+import ora11 from "ora";
+async function listCommand4(options) {
+  const spinner = options.json ? null : ora11("Fetching messages...").start();
+  const accessToken = await ensureValidToken(oauthConfig);
+  if (!accessToken) {
+    spinner?.stop();
+    outputError(
+      "Not authenticated. Run 'program auth login' first.",
+      options
+    );
+    process.exit(1);
+  }
+  try {
+    const url = new URL(`${BASE_URL}/api/cli/message`);
+    url.searchParams.set("projectId", options.project);
+    if (options.limit) {
+      url.searchParams.set("limit", options.limit.toString());
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        Authorization: `Bearer ${accessToken}`
+      }
+    });
+    const result = await response.json();
+    spinner?.stop();
+    if (!response.ok || !result.success) {
+      outputError(
+        result.error ?? `Failed to fetch messages: ${response.status}`,
+        options
+      );
+      process.exit(1);
+    }
+    if (options.json) {
+      outputSuccess(result, options);
+    } else {
+      const messages = result.messages ?? [];
+      if (messages.length === 0) {
+        console.log(chalk13.dim("No messages in this chat yet."));
+        return;
+      }
+      console.log(chalk13.bold(`Chat Messages (${messages.length}):
+`));
+      for (const msg of messages) {
+        let roleLabel = msg.role === "user" ? "You" : "Assistant";
+        if (msg.source) {
+          if (msg.source === "cli:claude-code") {
+            roleLabel = "Claude via CLI";
+          } else if (msg.source.startsWith("cli:")) {
+            roleLabel = `${roleLabel} via CLI`;
+          }
+        }
+        const textContent = msg.parts.filter((p) => p.type === "text" && !!p.text).map((p) => p.text).join("\n");
+        const toolCalls = msg.parts.filter(
+          (p) => p.type === "tool-invocation" || p.type === "tool-call"
+        );
+        const time = new Date(msg.createdAt).toLocaleTimeString();
+        const roleColor = msg.role === "user" ? chalk13.blue : chalk13.green;
+        console.log(roleColor(`[${time}] ${roleLabel}:`));
+        if (textContent) {
+          const truncated = textContent.length > 500 ? textContent.substring(0, 500) + "..." : textContent;
+          console.log(
+            truncated.split("\n").map((line) => `  ${line}`).join("\n")
+          );
+        }
+        if (toolCalls.length > 0) {
+          console.log(
+            chalk13.dim(`  [${toolCalls.length} tool call(s)]`)
+          );
+        }
+        console.log();
+      }
+    }
+  } catch (error) {
+    spinner?.stop();
+    outputError(
+      error instanceof Error ? error.message : "Request failed",
+      options
+    );
+    process.exit(1);
+  }
+}
+
+// src/commands/docs.ts
+var COMMAND_SCHEMA = {
+  name: "program",
+  version: "0.1.0",
+  description: "CLI for interacting with the Program video creation platform",
+  commands: {
+    auth: {
+      description: "Authentication commands",
+      subcommands: {
+        login: {
+          description: "Authenticate with the Program platform",
+          options: {
+            "--json": "Output as JSON"
+          },
+          example: "program auth login"
+        },
+        logout: {
+          description: "Log out from the Program platform",
+          options: {
+            "--json": "Output as JSON"
+          },
+          example: "program auth logout"
+        },
+        status: {
+          description: "Check authentication status",
+          options: {
+            "--json": "Output as JSON"
+          },
+          example: "program auth status --json"
+        }
+      }
+    },
+    project: {
+      description: "Project management commands",
+      subcommands: {
+        create: {
+          description: "Create a new project",
+          options: {
+            "--title <title>": "Project title",
+            "--description <desc>": "Project description",
+            "--json": "Output as JSON"
+          },
+          example: 'program project create --title "My Video" --json'
+        },
+        list: {
+          description: "List projects",
+          options: {
+            "--limit <n>": "Maximum number of projects to return",
+            "--json": "Output as JSON"
+          },
+          example: "program project list --json"
+        }
+      }
+    },
+    workflow: {
+      description: "Workflow template commands",
+      subcommands: {
+        list: {
+          description: "List available workflow templates",
+          options: {
+            "--limit <n>": "Maximum number of templates to return",
+            "--public-only": "Only show public templates",
+            "--json": "Output as JSON"
+          },
+          example: "program workflow list --json"
+        },
+        run: {
+          description: "Execute a workflow template",
+          args: {
+            templateId: "ID of the template to run"
+          },
+          options: {
+            "--project <id>": "Project ID to associate with execution",
+            "--input <json>": "JSON input for the workflow",
+            "--json": "Output as JSON"
+          },
+          example: `program workflow run tmpl_abc --project proj_123 --input '{"files":["src/main.ts"]}' --json`
+        },
+        status: {
+          description: "Check workflow execution status",
+          args: {
+            executionId: "ID of the execution to check"
+          },
+          options: {
+            "--watch": "Continuously poll for status updates",
+            "--interval <ms>": "Poll interval in milliseconds (default: 2000)",
+            "--json": "Output as JSON"
+          },
+          example: "program workflow status exec_789 --watch --json"
+        }
+      }
+    },
+    docs: {
+      description: "Display CLI documentation",
+      options: {
+        "--schema": "Output full command schema as JSON"
+      },
+      example: "program docs --schema"
+    }
+  },
+  globalOptions: {
+    "--help": "Display help information",
+    "--version": "Display version number"
+  },
+  notes: [
+    "Always use --json flag for parseable output when integrating with agents",
+    "Workflow inputs should be valid JSON strings",
+    "Run 'program auth login' first to authenticate"
+  ]
+};
+function docsCommand(options) {
+  if (options.schema ?? options.json) {
+    outputSuccess(COMMAND_SCHEMA, { json: true });
+  } else {
+    printHumanDocs();
+  }
+}
+function printHumanDocs() {
+  console.log(`
+Program CLI v${COMMAND_SCHEMA.version}
+${COMMAND_SCHEMA.description}
+
+COMMANDS:
+
+  auth login              Authenticate with the Program platform
+  auth logout             Log out from the Program platform
+  auth status             Check authentication status
+
+  project create          Create a new project
+  project list            List projects
+
+  workflow list           List available workflow templates
+  workflow run <id>       Execute a workflow template
+  workflow status <id>    Check workflow execution status
+
+  docs                    Display this documentation
+  docs --schema           Output full command schema as JSON
+
+GLOBAL OPTIONS:
+
+  --json                  Output as JSON (recommended for agents)
+  --help                  Display help information
+  --version               Display version number
+
+EXAMPLES:
+
+  # Authenticate
+  program auth login
+
+  # Create a project
+  program project create --title "My Video" --json
+
+  # Run a workflow
+  program workflow run tmpl_abc --project proj_123 --json
+
+  # Watch execution progress
+  program workflow status exec_789 --watch --json
+
+For agent integration, always use the --json flag.
+`);
+}
+
+// src/index.ts
+var program = new Command();
+program.name("program").description("CLI for the Program video creation platform").version("0.1.0");
+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);
+});
+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 tool = program.command("tool").description("Execute agent tools directly");
+tool.command("list").description("List available agent tools").option("--json", "Output as JSON").action(async (options) => {
+  await listCommand3(options);
+});
+tool.command("exec <toolName>").description("Execute an agent tool").requiredOption("--project <projectId>", "Project ID to execute tool against").option("--params <json>", "JSON parameters for the tool").option("--json", "Output as JSON").action(async (toolName, options) => {
+  await executeCommand(toolName, options);
+});
+var message = program.command("message").description("Manage messages in project chat");
+message.command("list").description("List messages in the project chat").requiredOption("--project <projectId>", "Project ID to list messages from").option("--limit <limit>", "Maximum number of messages to return", parseInt).option("--json", "Output as JSON").action(async (options) => {
+  await listCommand4(options);
+});
+message.command("send <text>").description(
+  "Log a text message to the project chat. NOTE: This only adds a message to the chat history - it does NOT trigger the AI agent. To perform actions, use 'tool exec' instead."
+).requiredOption("--project <projectId>", "Project ID to send message to").option("--role <role>", "Message role: user or assistant (default: assistant)").option("--json", "Output as JSON").action(async (text, options) => {
+  await sendCommand(text, options);
+});
+program.command("docs").description("Display CLI documentation and command schema").option("--schema", "Output full command schema as JSON").option("--json", "Output as JSON").action((options) => {
+  docsCommand(options);
+});
+program.parse();
+//# sourceMappingURL=index.js.map