flowName and deploy

Author: alexanderkirtzel

packages/cli/README.md

@@ -257,6 +257,40 @@ walkeros run serve flow.json --port 8080 --static-dir ./dist
 3. Runs in current Node.js process
 4. Press Ctrl+C for graceful shutdown
 
+### deploy
+
+Deploy flows to walkerOS cloud.
+
+```bash
+walkeros deploy start <flowId> [options]
+walkeros deploy status <flowId> [options]
+```
+
+**Options:**
+
+- `--project <id>` - Project ID (defaults to WALKEROS_PROJECT_ID)
+- `--flow <name>` - Flow name for multi-config flows
+- `--no-wait` - Do not wait for deployment to complete (start only)
+- `--json` - Output as JSON
+- `-v, --verbose` - Verbose output
+- `-s, --silent` - Suppress output
+
+**Examples:**
+
+```bash
+# Deploy a single-config flow
+walkeros deploy start cfg_abc123
+
+# Deploy a specific config from a multi-config flow
+walkeros deploy start cfg_abc123 --flow web
+
+# Check deployment status
+walkeros deploy status cfg_abc123 --flow server
+```
+
+When a flow has multiple configs, the CLI requires `--flow <name>` to specify
+which one to deploy. If omitted, the error message lists available names.
+
 ## Caching
 
 The CLI implements intelligent caching for faster builds:

packages/cli/src/__tests__/commands/deploy.test.ts

@@ -0,0 +1,204 @@
+import { createApiClient } from '../../core/api-client.js';
+import {
+  authenticatedFetch,
+  requireProjectId,
+  resolveBaseUrl,
+} from '../../core/auth.js';
+import { getFlow } from '../../commands/flows/index.js';
+import { deploy, getDeployment } from '../../commands/deploy/index.js';
+import { bundleRemote } from '../../commands/bundle/index.js';
+
+jest.mock('../../core/api-client.js');
+jest.mock('../../core/auth.js', () => ({
+  ...jest.requireActual('../../core/auth.js'),
+  requireProjectId: jest.fn().mockReturnValue('proj_default'),
+  resolveBaseUrl: jest.fn().mockReturnValue('https://app.walkeros.io'),
+  authenticatedFetch: jest.fn(),
+}));
+jest.mock('../../commands/flows/index.js', () => ({
+  getFlow: jest.fn(),
+}));
+
+const mockPost = jest.fn();
+const mockGet = jest.fn();
+
+(createApiClient as jest.Mock).mockReturnValue({
+  GET: mockGet,
+  POST: mockPost,
+  PATCH: jest.fn(),
+  DELETE: jest.fn(),
+});
+
+const mockGetFlow = jest.mocked(getFlow);
+const mockAuthFetch = jest.mocked(authenticatedFetch);
+
+const multiFlowContent = {
+  content: {
+    flows: {
+      web: { web: {} },
+      server: { server: {} },
+    },
+  },
+};
+
+describe('deploy', () => {
+  afterEach(() => jest.clearAllMocks());
+
+  describe('deploy() without flowName', () => {
+    it('calls legacy POST route', async () => {
+      mockPost.mockResolvedValue({
+        data: { status: 'bundling', deploymentId: 'dep_1' },
+      });
+      await deploy({ flowId: 'cfg_1', wait: false });
+      expect(mockPost).toHaveBeenCalledWith(
+        '/api/projects/{projectId}/flows/{flowId}/deploy',
+        { params: { path: { projectId: 'proj_default', flowId: 'cfg_1' } } },
+      );
+    });
+
+    it('handles AMBIGUOUS_CONFIG with helpful error', async () => {
+      mockPost.mockResolvedValue({
+        error: {
+          error: { message: 'Ambiguous config', code: 'AMBIGUOUS_CONFIG' },
+        },
+      });
+      mockGetFlow.mockResolvedValue(multiFlowContent as any);
+
+      await expect(deploy({ flowId: 'cfg_1' })).rejects.toThrow(
+        /Use --flow <name> to specify one/,
+      );
+    });
+  });
+
+  describe('deploy() with flowName', () => {
+    it('resolves configId and calls per-config route', async () => {
+      mockGetFlow.mockResolvedValue(multiFlowContent as any);
+      mockAuthFetch.mockResolvedValue(
+        new Response(
+          JSON.stringify({ status: 'bundling', deploymentId: 'dep_1' }),
+          {
+            status: 200,
+          },
+        ),
+      );
+
+      await deploy({ flowId: 'cfg_1', flowName: 'web', wait: false });
+
+      expect(mockGetFlow).toHaveBeenCalledWith({
+        flowId: 'cfg_1',
+        projectId: 'proj_default',
+      });
+      expect(mockAuthFetch).toHaveBeenCalledWith(
+        'https://app.walkeros.io/api/projects/proj_default/flows/cfg_1/configs/web/deploy',
+        { method: 'POST' },
+      );
+    });
+
+    it('throws with available names when flowName not found', async () => {
+      mockGetFlow.mockResolvedValue(multiFlowContent as any);
+
+      await expect(
+        deploy({ flowId: 'cfg_1', flowName: 'nonexistent' }),
+      ).rejects.toThrow(/Flow "nonexistent" not found. Available: web, server/);
+    });
+
+    it('polls advance endpoint when wait=true', async () => {
+      jest.useFakeTimers();
+      mockGetFlow.mockResolvedValue(multiFlowContent as any);
+
+      // First call: trigger deploy
+      mockAuthFetch.mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({ status: 'bundling', deploymentId: 'dep_1' }),
+          { status: 200 },
+        ),
+      );
+      // Second call: advance -> published
+      mockAuthFetch.mockResolvedValueOnce(
+        new Response(
+          JSON.stringify({
+            status: 'published',
+            publicUrl: 'https://cdn.example.com/walker.js',
+          }),
+          { status: 200 },
+        ),
+      );
+
+      const promise = deploy({
+        flowId: 'cfg_1',
+        flowName: 'web',
+        wait: true,
+      });
+
+      // Advance past the 3s poll delay
+      await jest.advanceTimersByTimeAsync(3000);
+
+      const result = await promise;
+
+      expect(result).toMatchObject({ status: 'published' });
+      expect(mockAuthFetch).toHaveBeenCalledTimes(2);
+      expect(mockAuthFetch).toHaveBeenLastCalledWith(
+        expect.stringContaining('/configs/web/deployments/dep_1/advance'),
+        { method: 'POST' },
+      );
+      jest.useRealTimers();
+    });
+  });
+
+  describe('getDeployment()', () => {
+    it('without flowName calls typed GET route', async () => {
+      mockGet.mockResolvedValue({
+        data: { id: 'dep_1', type: 'web', status: 'published' },
+      });
+      await getDeployment({ flowId: 'cfg_1' });
+      expect(mockGet).toHaveBeenCalledWith(
+        '/api/projects/{projectId}/flows/{flowId}/deploy',
+        { params: { path: { projectId: 'proj_default', flowId: 'cfg_1' } } },
+      );
+    });
+
+    it('with flowName calls per-config GET route', async () => {
+      mockGetFlow.mockResolvedValue(multiFlowContent as any);
+      mockAuthFetch.mockResolvedValue(
+        new Response(
+          JSON.stringify({ id: 'dep_1', type: 'web', status: 'published' }),
+          { status: 200 },
+        ),
+      );
+
+      await getDeployment({ flowId: 'cfg_1', flowName: 'web' });
+
+      expect(mockAuthFetch).toHaveBeenCalledWith(
+        'https://app.walkeros.io/api/projects/proj_default/flows/cfg_1/configs/web/deploy',
+      );
+    });
+  });
+
+  describe('bundleRemote()', () => {
+    it('without flowName sends only flow in body', async () => {
+      const content = { version: 1, flows: { default: {} } };
+      mockPost.mockResolvedValue({
+        data: 'console.log("bundle")',
+        response: { headers: new Headers() },
+      });
+      await bundleRemote({ content });
+      expect(mockPost).toHaveBeenCalledWith('/api/bundle', {
+        body: { flow: content },
+        parseAs: 'text',
+      });
+    });
+
+    it('with flowName includes flowName in body', async () => {
+      const content = { version: 1, flows: { web: {}, server: {} } };
+      mockPost.mockResolvedValue({
+        data: 'console.log("bundle")',
+        response: { headers: new Headers() },
+      });
+      await bundleRemote({ content, flowName: 'web' });
+      expect(mockPost).toHaveBeenCalledWith('/api/bundle', {
+        body: { flow: content, flowName: 'web' },
+        parseAs: 'text',
+      });
+    });
+  });
+});

packages/cli/src/cli.ts

@@ -357,6 +357,7 @@ deployCmd
   .command('start <flowId>')
   .description('Deploy a flow (auto-detects web or server)')
   .option('--project <id>', 'project ID (defaults to WALKEROS_PROJECT_ID)')
+  .option('--flow <name>', 'flow name for multi-config flows')
   .option('--no-wait', 'do not wait for deployment to complete')
   .option('-o, --output <path>', 'output file path')
   .option('--json', 'output as JSON')
@@ -370,6 +371,7 @@ deployCmd
   .command('status <flowId>')
   .description('Get the latest deployment status for a flow')
   .option('--project <id>', 'project ID (defaults to WALKEROS_PROJECT_ID)')
+  .option('--flow <name>', 'flow name for multi-config flows')
   .option('-o, --output <path>', 'output file path')
   .option('--json', 'output as JSON')
   .option('-v, --verbose', 'verbose output')

packages/cli/src/commands/bundle/index.ts

@@ -381,10 +381,13 @@ EXPOSE 8080
  */
 export async function bundleRemote(options: {
   content: Record<string, unknown>;
+  flowName?: string;
 }) {
   const client = createApiClient();
+  const body: Record<string, unknown> = { flow: options.content };
+  if (options.flowName) body.flowName = options.flowName;
   const { data, error, response } = await client.POST('/api/bundle', {
-    body: { flow: options.content } as unknown as Record<string, never>,
+    body: body as unknown as Record<string, never>,
     parseAs: 'text',
   });
   if (error)