@walkeros/cli 1.4.0-next-1771279991849 → 1.4.0-next-1771334965900

package/CHANGELOG.md

@@ -1,17 +1,18 @@
 # @walkeros/cli
 
-## 1.4.0-next-1771279991849
+## 1.4.0-next-1771334965900
 
 ### Minor Changes
 
+- a2f27d4: Add deploy command for web and server deployments
 - 7b2d750: Add walkerOS.json package convention for CDN-based schema discovery
 
 ### Patch Changes
 
 - 1ae6972: Fix missing trailing newline in JSON output
 - Updated dependencies [7b2d750]
-  - @walkeros/core@1.4.0-next-1771279991849
-  - @walkeros/server-core@1.0.6-next-1771279991849
+  - @walkeros/core@1.4.0-next-1771334965900
+  - @walkeros/server-core@1.0.6-next-1771334965900
 
 ## 1.3.0
 

package/dist/cli.js

@@ -798,7 +798,7 @@ async function resolveDependencies(pkg, packageDir, logger2, visited = /* @__PUR
   }
   return dependencies;
 }
-async function downloadPackages(packages, targetDir, logger2, useCache = true, configDir) {
+async function downloadPackages(packages, targetDir, logger2, useCache = true, configDir, tmpDir) {
   const packagePaths = /* @__PURE__ */ new Map();
   const downloadQueue = [...packages];
   const processed = /* @__PURE__ */ new Set();
@@ -841,8 +841,8 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
     }
     const packageSpec = `${pkg.name}@${pkg.version}`;
     const packageDir = getPackageDirectory(targetDir, pkg.name, pkg.version);
-    const cachedPath = await getCachedPackagePath(pkg);
-    if (useCache && await isPackageCached(pkg)) {
+    const cachedPath = await getCachedPackagePath(pkg, tmpDir);
+    if (useCache && await isPackageCached(pkg, tmpDir)) {
       if (userSpecifiedPackages.has(pkg.name)) {
         logger2.debug(`Downloading ${packageSpec} (cached)`);
       }
@@ -866,7 +866,7 @@ async function downloadPackages(packages, targetDir, logger2, useCache = true, c
     }
     try {
       await fs6.ensureDir(path7.dirname(packageDir));
-      const cacheDir = process.env.NPM_CACHE_DIR || getTmpPath(void 0, "cache", "npm");
+      const cacheDir = process.env.NPM_CACHE_DIR || getTmpPath(tmpDir, "cache", "npm");
       await withTimeout(
         pacote.extract(packageSpec, packageDir, {
           // Force npm registry download, prevent workspace resolution
@@ -1050,9 +1050,9 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
   const TEMP_DIR = buildOptions.tempDir || getTmpPath();
   if (buildOptions.cache !== false) {
     const configContent = generateCacheKeyContent(flowConfig, buildOptions);
-    const cached = await isBuildCached(configContent);
+    const cached = await isBuildCached(configContent, TEMP_DIR);
     if (cached) {
-      const cachedBuild = await getCachedBuild(configContent);
+      const cachedBuild = await getCachedBuild(configContent, TEMP_DIR);
       if (cachedBuild) {
         logger2.debug("Using cached build");
         const outputPath = path9.resolve(buildOptions.output);
@@ -1105,8 +1105,9 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
       TEMP_DIR,
       logger2,
       buildOptions.cache,
-      buildOptions.configDir
+      buildOptions.configDir,
       // For resolving relative local paths
+      TEMP_DIR
     );
     for (const [pkgName, pkgPath] of packagePaths.entries()) {
       if (pkgName.startsWith("@walkeros/")) {
@@ -1166,7 +1167,7 @@ async function bundleCore(flowConfig, buildOptions, logger2, showStats = false)
     if (buildOptions.cache !== false) {
       const configContent = generateCacheKeyContent(flowConfig, buildOptions);
       const buildOutput = await fs8.readFile(outputPath, "utf-8");
-      await cacheBuild(configContent, buildOutput);
+      await cacheBuild(configContent, buildOutput, TEMP_DIR);
       logger2.debug("Build cached for future use");
     }
     let stats;
@@ -2420,7 +2421,7 @@ async function simulateCommand(options) {
       const stdinContent = await readStdin();
       const fs15 = await import("fs-extra");
       const path15 = await import("path");
-      const tmpPath = path15.default.resolve(".tmp", "stdin-simulate.json");
+      const tmpPath = getTmpPath(void 0, "stdin-simulate.json");
       await fs15.default.ensureDir(path15.default.dirname(tmpPath));
       await fs15.default.writeFile(tmpPath, stdinContent, "utf-8");
       config = tmpPath;
@@ -2559,7 +2560,7 @@ async function pushCommand(options) {
     let config;
     if (isStdinPiped() && !options.config) {
       const stdinContent = await readStdin();
-      const tmpPath = path12.resolve(".tmp", "stdin-push.json");
+      const tmpPath = getTmpPath(void 0, "stdin-push.json");
       await fs12.ensureDir(path12.dirname(tmpPath));
       await fs12.writeFile(tmpPath, stdinContent, "utf-8");
       config = tmpPath;
@@ -2632,9 +2633,8 @@ async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
   const platform = getPlatform4(flowConfig);
   logger2.debug("Bundling flow configuration");
   const configDir = buildOptions.configDir || process.cwd();
-  const tempDir = path12.join(
-    configDir,
-    ".tmp",
+  const tempDir = getTmpPath(
+    void 0,
     `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
   setTempDir(tempDir);
@@ -2672,9 +2672,8 @@ async function executeConfigPush(options, validatedEvent, logger2, setTempDir) {
   }
 }
 async function executeBundlePush(bundleContent, platform, validatedEvent, logger2, setTempDir, context = {}) {
-  const tempDir = path12.join(
-    process.cwd(),
-    ".tmp",
+  const tempDir = getTmpPath(
+    void 0,
     `push-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
   setTempDir(tempDir);
@@ -2922,10 +2921,8 @@ function validatePort(port) {
 import path13 from "path";
 import fs13 from "fs-extra";
 async function prepareBundleForRun(configPath, options) {
-  const configDir = path13.dirname(path13.resolve(configPath));
-  const tempDir = path13.join(
-    configDir,
-    ".tmp",
+  const tempDir = getTmpPath(
+    void 0,
     `run-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`
   );
   await fs13.ensureDir(tempDir);
@@ -3991,6 +3988,115 @@ async function readFlowStdin() {
   return readStdin();
 }
 
+// src/commands/deploy/index.ts
+async function deploy(options) {
+  const projectId = options.projectId ?? requireProjectId();
+  const client = createApiClient();
+  const { data, error } = await client.POST(
+    "/api/projects/{projectId}/flows/{flowId}/deploy",
+    { params: { path: { projectId, flowId: options.flowId } } }
+  );
+  if (error)
+    throw new Error(error.error?.message || "Failed to start deployment");
+  if (!options.wait) return data;
+  const terminalStatuses = ["active", "published", "failed", "deleted"];
+  let status = data.status;
+  let result = { ...data };
+  while (!terminalStatuses.includes(status)) {
+    await new Promise((r) => setTimeout(r, 3e3));
+    const { data: advanced, error: advanceError } = await client.POST(
+      "/api/projects/{projectId}/flows/{flowId}/deploy/{deploymentId}/advance",
+      {
+        params: {
+          path: {
+            projectId,
+            flowId: options.flowId,
+            deploymentId: data.deploymentId
+          }
+        }
+      }
+    );
+    if (advanceError)
+      throw new Error(
+        advanceError.error?.message || "Failed to advance deployment"
+      );
+    if (advanced) {
+      status = advanced.status;
+      result = { ...advanced };
+    }
+  }
+  return result;
+}
+async function getDeployment(options) {
+  const projectId = options.projectId ?? requireProjectId();
+  const client = createApiClient();
+  const { data, error } = await client.GET(
+    "/api/projects/{projectId}/flows/{flowId}/deploy",
+    { params: { path: { projectId, flowId: options.flowId } } }
+  );
+  if (error)
+    throw new Error(error.error?.message || "Failed to get deployment");
+  return data;
+}
+async function deployCommand(flowId, options) {
+  const log = createCommandLogger(options);
+  try {
+    const result = await deploy({
+      flowId,
+      projectId: options.project,
+      wait: options.wait !== false
+    });
+    if (options.json) {
+      await writeResult(JSON.stringify(result, null, 2), options);
+      return;
+    }
+    const r = result;
+    if (r.status === "published") {
+      log.success(`Published: ${r.publicUrl}`);
+      if (r.scriptTag) log.info(`Script tag: ${r.scriptTag}`);
+    } else if (r.status === "active") {
+      log.success(`Active: ${r.containerUrl}`);
+    } else if (r.status === "failed") {
+      log.error(`Failed: ${r.errorMessage || "Unknown error"}`);
+      process.exit(1);
+    } else if (r.status === "bundling") {
+      log.info(`Deployment started: ${r.deploymentId} (${r.type})`);
+    } else {
+      log.info(`Status: ${r.status}`);
+    }
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : "Deploy failed");
+    process.exit(1);
+  }
+}
+async function getDeploymentCommand(flowId, options) {
+  const log = createCommandLogger(options);
+  try {
+    const result = await getDeployment({
+      flowId,
+      projectId: options.project
+    });
+    if (options.json) {
+      await writeResult(JSON.stringify(result, null, 2), options);
+      return;
+    }
+    if (!result) {
+      log.info("No deployment found");
+      return;
+    }
+    log.info(`Deployment: ${result.id}`);
+    log.info(`Type: ${result.type}`);
+    log.info(`Status: ${result.status}`);
+    if (result.containerUrl) log.info(`Endpoint: ${result.containerUrl}`);
+    if (result.publicUrl) log.info(`URL: ${result.publicUrl}`);
+    if (result.scriptTag) log.info(`Script tag: ${result.scriptTag}`);
+    if (result.errorMessage) log.error(`Error: ${result.errorMessage}`);
+  } catch (err) {
+    log.error(err instanceof Error ? err.message : "Failed to get deployment");
+    process.exit(1);
+  }
+}
+
 // src/cli.ts
 var program = new Command();
 program.name("walkeros").description("walkerOS CLI - Bundle and deploy walkerOS components").version(VERSION);
@@ -4118,6 +4224,13 @@ flowsCmd.command("delete <flowId>").description("Delete a flow").option("--proje
 flowsCmd.command("duplicate <flowId>").description("Duplicate a flow").option("--project <id>", "project ID (defaults to WALKEROS_PROJECT_ID)").option("--name <name>", "name for the copy").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (flowId, options) => {
   await duplicateFlowCommand(flowId, options);
 });
+var deployCmd = program.command("deploy").description("Deploy flows to walkerOS cloud");
+deployCmd.command("start <flowId>").description("Deploy a flow (auto-detects web or server)").option("--project <id>", "project ID (defaults to WALKEROS_PROJECT_ID)").option("--no-wait", "do not wait for deployment to complete").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (flowId, options) => {
+  await deployCommand(flowId, options);
+});
+deployCmd.command("status <flowId>").description("Get the latest deployment status for a flow").option("--project <id>", "project ID (defaults to WALKEROS_PROJECT_ID)").option("-o, --output <path>", "output file path").option("--json", "output as JSON").option("-v, --verbose", "verbose output").option("-s, --silent", "suppress output").action(async (flowId, options) => {
+  await getDeploymentCommand(flowId, options);
+});
 var runCmd = program.command("run").description("Run walkerOS flows in collect or serve mode");
 runCmd.command("collect [file]").description(
   "Run collector mode (event collection endpoint). Defaults to server-collect.mjs if no file specified."

package/dist/index.d.ts

@@ -2,6 +2,7 @@ import { Flow, Elb } from '@walkeros/core';
 export { Flow } from '@walkeros/core';
 import { BuildOptions as BuildOptions$1 } from 'esbuild';
 import { z } from '@walkeros/core/dev';
+import * as openapi_typescript_helpers from 'openapi-typescript-helpers';
 import * as openapi_fetch from 'openapi-fetch';
 
 /**
@@ -2322,6 +2323,171 @@ interface paths {
     patch?: never;
     trace?: never;
   };
+  '/api/projects/{projectId}/flows/{flowId}/deploy': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    /**
+     * Get latest deployment
+     * @description Get the latest deployment for a flow.
+     */
+    get: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path: {
+          projectId: string;
+          flowId: string;
+        };
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Latest deployment (or null) */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': components['schemas']['Deployment'] | null;
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': components['schemas']['ErrorResponse'];
+          };
+        };
+      };
+    };
+    put?: never;
+    /**
+     * Deploy flow
+     * @description Start a deployment for a flow. Auto-detects web or server from flow content.
+     */
+    post: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path: {
+          projectId: string;
+          flowId: string;
+        };
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Deployment started */
+        201: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': components['schemas']['DeployResponse'];
+          };
+        };
+        /** @description Invalid flow */
+        400: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': components['schemas']['ErrorResponse'];
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': components['schemas']['ErrorResponse'];
+          };
+        };
+        /** @description Not found */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': components['schemas']['ErrorResponse'];
+          };
+        };
+      };
+    };
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
+  '/api/projects/{projectId}/flows/{flowId}/deploy/{deploymentId}/advance': {
+    parameters: {
+      query?: never;
+      header?: never;
+      path?: never;
+      cookie?: never;
+    };
+    get?: never;
+    put?: never;
+    /**
+     * Advance deployment
+     * @description Advance the deployment state machine. Poll until terminal status.
+     */
+    post: {
+      parameters: {
+        query?: never;
+        header?: never;
+        path: {
+          projectId: string;
+          flowId: string;
+          deploymentId: string;
+        };
+        cookie?: never;
+      };
+      requestBody?: never;
+      responses: {
+        /** @description Current deployment state */
+        200: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': components['schemas']['Deployment'];
+          };
+        };
+        /** @description Unauthorized */
+        401: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': components['schemas']['ErrorResponse'];
+          };
+        };
+        /** @description Not found */
+        404: {
+          headers: {
+            [name: string]: unknown;
+          };
+          content: {
+            'application/json': components['schemas']['ErrorResponse'];
+          };
+        };
+      };
+    };
+    delete?: never;
+    options?: never;
+    head?: never;
+    patch?: never;
+    trace?: never;
+  };
   '/api/projects/{projectId}/observe/ticket': {
     parameters: {
       query?: never;
@@ -2964,6 +3130,38 @@ interface components {
     ValidateTicketRequest: {
       ticket: string;
     };
+    Deployment: {
+      /** @example dep_a1b2c3d4 */
+      id: string;
+      /** @example flow_a1b2c3d4 */
+      flowId: string;
+      /** @enum {string} */
+      type: 'web' | 'server';
+      /** @enum {string} */
+      status:
+        | 'bundling'
+        | 'deploying'
+        | 'active'
+        | 'failed'
+        | 'deleted'
+        | 'published';
+      containerUrl?: string | null;
+      publicUrl?: string | null;
+      scriptTag?: string | null;
+      errorMessage?: string | null;
+      /** Format: date-time */
+      createdAt: string;
+      /** Format: date-time */
+      updatedAt: string;
+    };
+    DeployResponse: {
+      /** @example dep_a1b2c3d4 */
+      deploymentId: string;
+      /** @enum {string} */
+      type: 'web' | 'server';
+      /** @example bundling */
+      status: string;
+    };
     HealthResponse: {
       /** @example ok */
       status: string;
@@ -2976,6 +3174,46 @@ interface components {
   pathItems: never;
 }
 
+interface DeployOptions {
+    flowId: string;
+    projectId?: string;
+    wait?: boolean;
+}
+declare function deploy(options: DeployOptions): Promise<Record<string, unknown> | {
+    deploymentId: string;
+    type: "web" | "server";
+    status: string;
+}>;
+declare function getDeployment(options: {
+    flowId: string;
+    projectId?: string;
+}): Promise<openapi_typescript_helpers.Readable<openapi_typescript_helpers.SuccessResponse<{
+    200: {
+        headers: {
+            [name: string]: unknown;
+        };
+        content: {
+            "application/json": components["schemas"]["Deployment"] | null;
+        };
+    };
+    401: {
+        headers: {
+            [name: string]: unknown;
+        };
+        content: {
+            "application/json": components["schemas"]["ErrorResponse"];
+        };
+    };
+}, `${string}/${string}`>>>;
+interface DeployCommandOptions extends GlobalOptions {
+    project?: string;
+    wait?: boolean;
+    output?: string;
+    json?: boolean;
+}
+declare function deployCommand(flowId: string, options: DeployCommandOptions): Promise<void>;
+declare function getDeploymentCommand(flowId: string, options: DeployCommandOptions): Promise<void>;
+
 declare function createApiClient(): openapi_fetch.Client<paths, `${string}/${string}`>;
 
-export { type BuildOptions, type BundleStats, type CLIBuildOptions, type GlobalOptions, type ListFlowsOptions, type MinifyOptions, type PushResult, type RunCommandOptions, type RunMode, type RunOptions, type RunResult, type SimulationResult, type ValidateResult, type ValidationError, type ValidationType, type ValidationWarning, bundle, bundleCommand, bundleRemote, createApiClient, createFlow, createFlowCommand, createProject, createProjectCommand, deleteFlow, deleteFlowCommand, deleteProject, deleteProjectCommand, duplicateFlow, duplicateFlowCommand, getAuthHeaders, getFlow, getFlowCommand, getProject, getProjectCommand, getToken, listFlows, listFlowsCommand, listProjects, listProjectsCommand, loginCommand, logoutCommand, push, pushCommand, requireProjectId, resolveBaseUrl, run, runCommand, simulate, simulateCommand, updateFlow, updateFlowCommand, updateProject, updateProjectCommand, validate, validateCommand, whoami, whoamiCommand };
+export { type BuildOptions, type BundleStats, type CLIBuildOptions, type DeployOptions, type GlobalOptions, type ListFlowsOptions, type MinifyOptions, type PushResult, type RunCommandOptions, type RunMode, type RunOptions, type RunResult, type SimulationResult, type ValidateResult, type ValidationError, type ValidationType, type ValidationWarning, bundle, bundleCommand, bundleRemote, createApiClient, createFlow, createFlowCommand, createProject, createProjectCommand, deleteFlow, deleteFlowCommand, deleteProject, deleteProjectCommand, deploy, deployCommand, duplicateFlow, duplicateFlowCommand, getAuthHeaders, getDeployment, getDeploymentCommand, getFlow, getFlowCommand, getProject, getProjectCommand, getToken, listFlows, listFlowsCommand, listProjects, listProjectsCommand, loginCommand, logoutCommand, push, pushCommand, requireProjectId, resolveBaseUrl, run, runCommand, simulate, simulateCommand, updateFlow, updateFlowCommand, updateProject, updateProjectCommand, validate, validateCommand, whoami, whoamiCommand };