@vm0/cli 9.22.0 → 9.24.0

package/index.js

@@ -61,7 +61,7 @@ if (DSN) {
     }
   });
   Sentry.setContext("cli", {
-    version: "9.22.0",
+    version: "9.24.0",
     command: process.argv.slice(2).join(" ")
   });
   Sentry.setContext("runtime", {
@@ -72,7 +72,7 @@ if (DSN) {
 }
 
 // src/index.ts
-import { Command as Command68 } from "commander";
+import { Command as Command72 } from "commander";
 
 // src/commands/auth/index.ts
 import { Command as Command5 } from "commander";
@@ -3138,29 +3138,255 @@ var llmChatContract = c18.router({
   }
 });
 
-// ../../packages/core/src/contracts/public/agents.ts
+// ../../packages/core/src/contracts/compose-jobs.ts
 import { z as z23 } from "zod";
 var c19 = initContract();
-var publicAgentSchema = z23.object({
-  id: z23.string(),
-  name: z23.string(),
-  currentVersionId: z23.string().nullable(),
+var composeJobStatusSchema = z23.enum([
+  "pending",
+  "running",
+  "completed",
+  "failed"
+]);
+var composeJobResultSchema = z23.object({
+  composeId: z23.string(),
+  composeName: z23.string(),
+  versionId: z23.string(),
+  warnings: z23.array(z23.string())
+});
+var createComposeJobRequestSchema = z23.object({
+  githubUrl: z23.string().url().startsWith("https://github.com/"),
+  overwrite: z23.boolean().optional().default(false)
+});
+var composeJobResponseSchema = z23.object({
+  jobId: z23.string(),
+  status: composeJobStatusSchema,
+  githubUrl: z23.string(),
+  result: composeJobResultSchema.optional(),
+  error: z23.string().optional(),
+  createdAt: z23.string(),
+  startedAt: z23.string().optional(),
+  completedAt: z23.string().optional()
+});
+var composeJobsMainContract = c19.router({
+  /**
+   * POST /api/compose/from-github
+   * Create a new compose job from GitHub URL
+   */
+  create: {
+    method: "POST",
+    path: "/api/compose/from-github",
+    headers: authHeadersSchema,
+    body: createComposeJobRequestSchema,
+    responses: {
+      201: composeJobResponseSchema,
+      200: composeJobResponseSchema,
+      // Returned when existing job found (idempotency)
+      400: apiErrorSchema,
+      401: apiErrorSchema
+    },
+    summary: "Create compose job from GitHub URL"
+  }
+});
+var composeJobsByIdContract = c19.router({
+  /**
+   * GET /api/compose/from-github/:jobId
+   * Get compose job status and result
+   */
+  getById: {
+    method: "GET",
+    path: "/api/compose/from-github/:jobId",
+    headers: authHeadersSchema,
+    pathParams: z23.object({
+      jobId: z23.string().uuid()
+    }),
+    responses: {
+      200: composeJobResponseSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Get compose job status"
+  }
+});
+var webhookComposeCompleteContract = c19.router({
+  /**
+   * POST /api/webhooks/compose/complete
+   * Handle compose job completion from sandbox
+   */
+  complete: {
+    method: "POST",
+    path: "/api/webhooks/compose/complete",
+    headers: authHeadersSchema,
+    body: z23.object({
+      jobId: z23.string().uuid(),
+      success: z23.boolean(),
+      // Result from CLI compose command
+      result: composeJobResultSchema.optional(),
+      error: z23.string().optional()
+    }),
+    responses: {
+      200: z23.object({
+        success: z23.boolean()
+      }),
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema
+    },
+    summary: "Handle compose job completion"
+  }
+});
+
+// ../../packages/core/src/contracts/connectors.ts
+import { z as z24 } from "zod";
+var c20 = initContract();
+var connectorTypeSchema = z24.enum(["github"]);
+var connectorResponseSchema = z24.object({
+  id: z24.string().uuid(),
+  type: connectorTypeSchema,
+  authMethod: z24.string(),
+  externalId: z24.string().nullable(),
+  externalUsername: z24.string().nullable(),
+  externalEmail: z24.string().nullable(),
+  oauthScopes: z24.array(z24.string()).nullable(),
+  createdAt: z24.string(),
+  updatedAt: z24.string()
+});
+var connectorListResponseSchema = z24.object({
+  connectors: z24.array(connectorResponseSchema)
+});
+var connectorsMainContract = c20.router({
+  list: {
+    method: "GET",
+    path: "/api/connectors",
+    headers: authHeadersSchema,
+    responses: {
+      200: connectorListResponseSchema,
+      401: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "List all connectors for the authenticated user"
+  }
+});
+var connectorsByTypeContract = c20.router({
+  get: {
+    method: "GET",
+    path: "/api/connectors/:type",
+    headers: authHeadersSchema,
+    pathParams: z24.object({
+      type: connectorTypeSchema
+    }),
+    responses: {
+      200: connectorResponseSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Get connector status by type"
+  },
+  delete: {
+    method: "DELETE",
+    path: "/api/connectors/:type",
+    headers: authHeadersSchema,
+    pathParams: z24.object({
+      type: connectorTypeSchema
+    }),
+    responses: {
+      204: c20.noBody(),
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Disconnect a connector"
+  }
+});
+var connectorSessionStatusSchema = z24.enum([
+  "pending",
+  "complete",
+  "expired",
+  "error"
+]);
+var connectorSessionResponseSchema = z24.object({
+  id: z24.string().uuid(),
+  code: z24.string(),
+  type: connectorTypeSchema,
+  status: connectorSessionStatusSchema,
+  verificationUrl: z24.string(),
+  expiresIn: z24.number(),
+  interval: z24.number(),
+  errorMessage: z24.string().nullable().optional()
+});
+var connectorSessionStatusResponseSchema = z24.object({
+  status: connectorSessionStatusSchema,
+  errorMessage: z24.string().nullable().optional()
+});
+var connectorSessionsContract = c20.router({
+  /**
+   * POST /api/connectors/:type/sessions
+   * Create a new connector session for CLI device flow
+   */
+  create: {
+    method: "POST",
+    path: "/api/connectors/:type/sessions",
+    headers: authHeadersSchema,
+    pathParams: z24.object({
+      type: connectorTypeSchema
+    }),
+    body: z24.object({}).optional(),
+    responses: {
+      200: connectorSessionResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Create connector session for CLI device flow"
+  }
+});
+var connectorSessionByIdContract = c20.router({
+  /**
+   * GET /api/connectors/:type/sessions/:sessionId
+   * Get connector session status (for CLI polling)
+   */
+  get: {
+    method: "GET",
+    path: "/api/connectors/:type/sessions/:sessionId",
+    headers: authHeadersSchema,
+    pathParams: z24.object({
+      type: connectorTypeSchema,
+      sessionId: z24.string().uuid()
+    }),
+    responses: {
+      200: connectorSessionStatusResponseSchema,
+      400: apiErrorSchema,
+      401: apiErrorSchema,
+      404: apiErrorSchema,
+      500: apiErrorSchema
+    },
+    summary: "Get connector session status"
+  }
+});
+
+// ../../packages/core/src/contracts/public/agents.ts
+import { z as z25 } from "zod";
+var c21 = initContract();
+var publicAgentSchema = z25.object({
+  id: z25.string(),
+  name: z25.string(),
+  currentVersionId: z25.string().nullable(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema
 });
-var agentVersionSchema = z23.object({
-  id: z23.string(),
-  agentId: z23.string(),
-  versionNumber: z23.number(),
+var agentVersionSchema = z25.object({
+  id: z25.string(),
+  agentId: z25.string(),
+  versionNumber: z25.number(),
   createdAt: timestampSchema
 });
 var publicAgentDetailSchema = publicAgentSchema;
 var paginatedAgentsSchema = createPaginatedResponseSchema(publicAgentSchema);
 var paginatedAgentVersionsSchema = createPaginatedResponseSchema(agentVersionSchema);
 var agentListQuerySchema = listQuerySchema.extend({
-  name: z23.string().optional()
+  name: z25.string().optional()
 });
-var publicAgentsListContract = c19.router({
+var publicAgentsListContract = c21.router({
   list: {
     method: "GET",
     path: "/v1/agents",
@@ -3175,13 +3401,13 @@ var publicAgentsListContract = c19.router({
     description: "List all agents in the current scope with pagination. Use the `name` query parameter to filter by agent name."
   }
 });
-var publicAgentByIdContract = c19.router({
+var publicAgentByIdContract = c21.router({
   get: {
     method: "GET",
     path: "/v1/agents/:id",
     headers: authHeadersSchema,
-    pathParams: z23.object({
-      id: z23.string().min(1, "Agent ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Agent ID is required")
     }),
     responses: {
       200: publicAgentDetailSchema,
@@ -3193,13 +3419,13 @@ var publicAgentByIdContract = c19.router({
     description: "Get agent details by ID"
   }
 });
-var publicAgentVersionsContract = c19.router({
+var publicAgentVersionsContract = c21.router({
   list: {
     method: "GET",
     path: "/v1/agents/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z23.object({
-      id: z23.string().min(1, "Agent ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Agent ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -3214,9 +3440,9 @@ var publicAgentVersionsContract = c19.router({
 });
 
 // ../../packages/core/src/contracts/public/runs.ts
-import { z as z24 } from "zod";
-var c20 = initContract();
-var publicRunStatusSchema = z24.enum([
+import { z as z26 } from "zod";
+var c22 = initContract();
+var publicRunStatusSchema = z26.enum([
   "pending",
   "running",
   "completed",
@@ -3224,54 +3450,54 @@ var publicRunStatusSchema = z24.enum([
   "timeout",
   "cancelled"
 ]);
-var publicRunSchema = z24.object({
-  id: z24.string(),
-  agentId: z24.string(),
-  agentName: z24.string(),
+var publicRunSchema = z26.object({
+  id: z26.string(),
+  agentId: z26.string(),
+  agentName: z26.string(),
   status: publicRunStatusSchema,
-  prompt: z24.string(),
+  prompt: z26.string(),
   createdAt: timestampSchema,
   startedAt: timestampSchema.nullable(),
   completedAt: timestampSchema.nullable()
 });
 var publicRunDetailSchema = publicRunSchema.extend({
-  error: z24.string().nullable(),
-  executionTimeMs: z24.number().nullable(),
-  checkpointId: z24.string().nullable(),
-  sessionId: z24.string().nullable(),
-  artifactName: z24.string().nullable(),
-  artifactVersion: z24.string().nullable(),
-  volumes: z24.record(z24.string(), z24.string()).optional()
+  error: z26.string().nullable(),
+  executionTimeMs: z26.number().nullable(),
+  checkpointId: z26.string().nullable(),
+  sessionId: z26.string().nullable(),
+  artifactName: z26.string().nullable(),
+  artifactVersion: z26.string().nullable(),
+  volumes: z26.record(z26.string(), z26.string()).optional()
 });
 var paginatedRunsSchema = createPaginatedResponseSchema(publicRunSchema);
-var createRunRequestSchema = z24.object({
+var createRunRequestSchema = z26.object({
   // Agent identification (one of: agent, agentId, sessionId, checkpointId)
-  agent: z24.string().optional(),
+  agent: z26.string().optional(),
   // Agent name
-  agentId: z24.string().optional(),
+  agentId: z26.string().optional(),
   // Agent ID
-  agentVersion: z24.string().optional(),
+  agentVersion: z26.string().optional(),
   // Version specifier (e.g., "latest", "v1", specific ID)
   // Continue session
-  sessionId: z24.string().optional(),
+  sessionId: z26.string().optional(),
   // Resume from checkpoint
-  checkpointId: z24.string().optional(),
+  checkpointId: z26.string().optional(),
   // Required
-  prompt: z24.string().min(1, "Prompt is required"),
+  prompt: z26.string().min(1, "Prompt is required"),
   // Optional configuration
-  variables: z24.record(z24.string(), z24.string()).optional(),
-  secrets: z24.record(z24.string(), z24.string()).optional(),
-  artifactName: z24.string().optional(),
+  variables: z26.record(z26.string(), z26.string()).optional(),
+  secrets: z26.record(z26.string(), z26.string()).optional(),
+  artifactName: z26.string().optional(),
   // Artifact name to mount
-  artifactVersion: z24.string().optional(),
+  artifactVersion: z26.string().optional(),
   // Artifact version (defaults to latest)
-  volumes: z24.record(z24.string(), z24.string()).optional()
+  volumes: z26.record(z26.string(), z26.string()).optional()
   // volume_name -> version
 });
 var runListQuerySchema = listQuerySchema.extend({
   status: publicRunStatusSchema.optional()
 });
-var publicRunsListContract = c20.router({
+var publicRunsListContract = c22.router({
   list: {
     method: "GET",
     path: "/v1/runs",
@@ -3303,13 +3529,13 @@ var publicRunsListContract = c20.router({
     description: "Create and execute a new agent run. Returns 202 Accepted as runs execute asynchronously."
   }
 });
-var publicRunByIdContract = c20.router({
+var publicRunByIdContract = c22.router({
   get: {
     method: "GET",
     path: "/v1/runs/:id",
     headers: authHeadersSchema,
-    pathParams: z24.object({
-      id: z24.string().min(1, "Run ID is required")
+    pathParams: z26.object({
+      id: z26.string().min(1, "Run ID is required")
     }),
     responses: {
       200: publicRunDetailSchema,
@@ -3321,15 +3547,15 @@ var publicRunByIdContract = c20.router({
     description: "Get run details by ID"
   }
 });
-var publicRunCancelContract = c20.router({
+var publicRunCancelContract = c22.router({
   cancel: {
     method: "POST",
     path: "/v1/runs/:id/cancel",
     headers: authHeadersSchema,
-    pathParams: z24.object({
-      id: z24.string().min(1, "Run ID is required")
+    pathParams: z26.object({
+      id: z26.string().min(1, "Run ID is required")
     }),
-    body: z24.undefined(),
+    body: z26.undefined(),
     responses: {
       200: publicRunDetailSchema,
       400: publicApiErrorSchema,
@@ -3342,27 +3568,27 @@ var publicRunCancelContract = c20.router({
     description: "Cancel a pending or running execution"
   }
 });
-var logEntrySchema = z24.object({
+var logEntrySchema = z26.object({
   timestamp: timestampSchema,
-  type: z24.enum(["agent", "system", "network"]),
-  level: z24.enum(["debug", "info", "warn", "error"]),
-  message: z24.string(),
-  metadata: z24.record(z24.string(), z24.unknown()).optional()
+  type: z26.enum(["agent", "system", "network"]),
+  level: z26.enum(["debug", "info", "warn", "error"]),
+  message: z26.string(),
+  metadata: z26.record(z26.string(), z26.unknown()).optional()
 });
 var paginatedLogsSchema = createPaginatedResponseSchema(logEntrySchema);
 var logsQuerySchema = listQuerySchema.extend({
-  type: z24.enum(["agent", "system", "network", "all"]).default("all"),
+  type: z26.enum(["agent", "system", "network", "all"]).default("all"),
   since: timestampSchema.optional(),
   until: timestampSchema.optional(),
-  order: z24.enum(["asc", "desc"]).default("asc")
+  order: z26.enum(["asc", "desc"]).default("asc")
 });
-var publicRunLogsContract = c20.router({
+var publicRunLogsContract = c22.router({
   getLogs: {
     method: "GET",
     path: "/v1/runs/:id/logs",
     headers: authHeadersSchema,
-    pathParams: z24.object({
-      id: z24.string().min(1, "Run ID is required")
+    pathParams: z26.object({
+      id: z26.string().min(1, "Run ID is required")
     }),
     query: logsQuerySchema,
     responses: {
@@ -3375,30 +3601,30 @@ var publicRunLogsContract = c20.router({
     description: "Get unified logs for a run. Combines agent, system, and network logs."
   }
 });
-var metricPointSchema = z24.object({
+var metricPointSchema = z26.object({
   timestamp: timestampSchema,
-  cpuPercent: z24.number(),
-  memoryUsedMb: z24.number(),
-  memoryTotalMb: z24.number(),
-  diskUsedMb: z24.number(),
-  diskTotalMb: z24.number()
-});
-var metricsSummarySchema = z24.object({
-  avgCpuPercent: z24.number(),
-  maxMemoryUsedMb: z24.number(),
-  totalDurationMs: z24.number().nullable()
-});
-var metricsResponseSchema2 = z24.object({
-  data: z24.array(metricPointSchema),
+  cpuPercent: z26.number(),
+  memoryUsedMb: z26.number(),
+  memoryTotalMb: z26.number(),
+  diskUsedMb: z26.number(),
+  diskTotalMb: z26.number()
+});
+var metricsSummarySchema = z26.object({
+  avgCpuPercent: z26.number(),
+  maxMemoryUsedMb: z26.number(),
+  totalDurationMs: z26.number().nullable()
+});
+var metricsResponseSchema2 = z26.object({
+  data: z26.array(metricPointSchema),
   summary: metricsSummarySchema
 });
-var publicRunMetricsContract = c20.router({
+var publicRunMetricsContract = c22.router({
   getMetrics: {
     method: "GET",
     path: "/v1/runs/:id/metrics",
     headers: authHeadersSchema,
-    pathParams: z24.object({
-      id: z24.string().min(1, "Run ID is required")
+    pathParams: z26.object({
+      id: z26.string().min(1, "Run ID is required")
     }),
     responses: {
       200: metricsResponseSchema2,
@@ -3410,7 +3636,7 @@ var publicRunMetricsContract = c20.router({
     description: "Get CPU, memory, and disk metrics for a run"
   }
 });
-var sseEventTypeSchema = z24.enum([
+var sseEventTypeSchema = z26.enum([
   "status",
   // Run status change
   "output",
@@ -3422,26 +3648,26 @@ var sseEventTypeSchema = z24.enum([
   "heartbeat"
   // Keep-alive
 ]);
-var sseEventSchema = z24.object({
+var sseEventSchema = z26.object({
   event: sseEventTypeSchema,
-  data: z24.unknown(),
-  id: z24.string().optional()
+  data: z26.unknown(),
+  id: z26.string().optional()
   // For Last-Event-ID reconnection
 });
-var publicRunEventsContract = c20.router({
+var publicRunEventsContract = c22.router({
   streamEvents: {
     method: "GET",
     path: "/v1/runs/:id/events",
     headers: authHeadersSchema,
-    pathParams: z24.object({
-      id: z24.string().min(1, "Run ID is required")
+    pathParams: z26.object({
+      id: z26.string().min(1, "Run ID is required")
     }),
-    query: z24.object({
-      lastEventId: z24.string().optional()
+    query: z26.object({
+      lastEventId: z26.string().optional()
       // For reconnection
     }),
     responses: {
-      200: z24.any(),
+      200: z26.any(),
       // SSE stream - actual content is text/event-stream
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -3453,28 +3679,28 @@ var publicRunEventsContract = c20.router({
 });
 
 // ../../packages/core/src/contracts/public/artifacts.ts
-import { z as z25 } from "zod";
-var c21 = initContract();
-var publicArtifactSchema = z25.object({
-  id: z25.string(),
-  name: z25.string(),
-  currentVersionId: z25.string().nullable(),
-  size: z25.number(),
+import { z as z27 } from "zod";
+var c23 = initContract();
+var publicArtifactSchema = z27.object({
+  id: z27.string(),
+  name: z27.string(),
+  currentVersionId: z27.string().nullable(),
+  size: z27.number(),
   // Total size in bytes
-  fileCount: z25.number(),
+  fileCount: z27.number(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema
 });
-var artifactVersionSchema = z25.object({
-  id: z25.string(),
+var artifactVersionSchema = z27.object({
+  id: z27.string(),
   // SHA-256 content hash
-  artifactId: z25.string(),
-  size: z25.number(),
+  artifactId: z27.string(),
+  size: z27.number(),
   // Size in bytes
-  fileCount: z25.number(),
-  message: z25.string().nullable(),
+  fileCount: z27.number(),
+  message: z27.string().nullable(),
   // Optional commit message
-  createdBy: z25.string(),
+  createdBy: z27.string(),
   createdAt: timestampSchema
 });
 var publicArtifactDetailSchema = publicArtifactSchema.extend({
@@ -3484,7 +3710,7 @@ var paginatedArtifactsSchema = createPaginatedResponseSchema(publicArtifactSchem
 var paginatedArtifactVersionsSchema = createPaginatedResponseSchema(
   artifactVersionSchema
 );
-var publicArtifactsListContract = c21.router({
+var publicArtifactsListContract = c23.router({
   list: {
     method: "GET",
     path: "/v1/artifacts",
@@ -3499,13 +3725,13 @@ var publicArtifactsListContract = c21.router({
     description: "List all artifacts in the current scope with pagination"
   }
 });
-var publicArtifactByIdContract = c21.router({
+var publicArtifactByIdContract = c23.router({
   get: {
     method: "GET",
     path: "/v1/artifacts/:id",
     headers: authHeadersSchema,
-    pathParams: z25.object({
-      id: z25.string().min(1, "Artifact ID is required")
+    pathParams: z27.object({
+      id: z27.string().min(1, "Artifact ID is required")
     }),
     responses: {
       200: publicArtifactDetailSchema,
@@ -3517,13 +3743,13 @@ var publicArtifactByIdContract = c21.router({
     description: "Get artifact details by ID"
   }
 });
-var publicArtifactVersionsContract = c21.router({
+var publicArtifactVersionsContract = c23.router({
   list: {
     method: "GET",
     path: "/v1/artifacts/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z25.object({
-      id: z25.string().min(1, "Artifact ID is required")
+    pathParams: z27.object({
+      id: z27.string().min(1, "Artifact ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -3536,20 +3762,20 @@ var publicArtifactVersionsContract = c21.router({
     description: "List all versions of an artifact with pagination"
   }
 });
-var publicArtifactDownloadContract = c21.router({
+var publicArtifactDownloadContract = c23.router({
   download: {
     method: "GET",
     path: "/v1/artifacts/:id/download",
     headers: authHeadersSchema,
-    pathParams: z25.object({
-      id: z25.string().min(1, "Artifact ID is required")
+    pathParams: z27.object({
+      id: z27.string().min(1, "Artifact ID is required")
     }),
-    query: z25.object({
-      versionId: z25.string().optional()
+    query: z27.object({
+      versionId: z27.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z25.undefined(),
+      302: z27.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -3561,28 +3787,28 @@ var publicArtifactDownloadContract = c21.router({
 });
 
 // ../../packages/core/src/contracts/public/volumes.ts
-import { z as z26 } from "zod";
-var c22 = initContract();
-var publicVolumeSchema = z26.object({
-  id: z26.string(),
-  name: z26.string(),
-  currentVersionId: z26.string().nullable(),
-  size: z26.number(),
+import { z as z28 } from "zod";
+var c24 = initContract();
+var publicVolumeSchema = z28.object({
+  id: z28.string(),
+  name: z28.string(),
+  currentVersionId: z28.string().nullable(),
+  size: z28.number(),
   // Total size in bytes
-  fileCount: z26.number(),
+  fileCount: z28.number(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema
 });
-var volumeVersionSchema = z26.object({
-  id: z26.string(),
+var volumeVersionSchema = z28.object({
+  id: z28.string(),
   // SHA-256 content hash
-  volumeId: z26.string(),
-  size: z26.number(),
+  volumeId: z28.string(),
+  size: z28.number(),
   // Size in bytes
-  fileCount: z26.number(),
-  message: z26.string().nullable(),
+  fileCount: z28.number(),
+  message: z28.string().nullable(),
   // Optional commit message
-  createdBy: z26.string(),
+  createdBy: z28.string(),
   createdAt: timestampSchema
 });
 var publicVolumeDetailSchema = publicVolumeSchema.extend({
@@ -3590,7 +3816,7 @@ var publicVolumeDetailSchema = publicVolumeSchema.extend({
 });
 var paginatedVolumesSchema = createPaginatedResponseSchema(publicVolumeSchema);
 var paginatedVolumeVersionsSchema = createPaginatedResponseSchema(volumeVersionSchema);
-var publicVolumesListContract = c22.router({
+var publicVolumesListContract = c24.router({
   list: {
     method: "GET",
     path: "/v1/volumes",
@@ -3605,13 +3831,13 @@ var publicVolumesListContract = c22.router({
     description: "List all volumes in the current scope with pagination"
   }
 });
-var publicVolumeByIdContract = c22.router({
+var publicVolumeByIdContract = c24.router({
   get: {
     method: "GET",
     path: "/v1/volumes/:id",
     headers: authHeadersSchema,
-    pathParams: z26.object({
-      id: z26.string().min(1, "Volume ID is required")
+    pathParams: z28.object({
+      id: z28.string().min(1, "Volume ID is required")
     }),
     responses: {
       200: publicVolumeDetailSchema,
@@ -3623,13 +3849,13 @@ var publicVolumeByIdContract = c22.router({
     description: "Get volume details by ID"
   }
 });
-var publicVolumeVersionsContract = c22.router({
+var publicVolumeVersionsContract = c24.router({
   list: {
     method: "GET",
     path: "/v1/volumes/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z26.object({
-      id: z26.string().min(1, "Volume ID is required")
+    pathParams: z28.object({
+      id: z28.string().min(1, "Volume ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -3642,20 +3868,20 @@ var publicVolumeVersionsContract = c22.router({
     description: "List all versions of a volume with pagination"
   }
 });
-var publicVolumeDownloadContract = c22.router({
+var publicVolumeDownloadContract = c24.router({
   download: {
     method: "GET",
     path: "/v1/volumes/:id/download",
     headers: authHeadersSchema,
-    pathParams: z26.object({
-      id: z26.string().min(1, "Volume ID is required")
+    pathParams: z28.object({
+      id: z28.string().min(1, "Volume ID is required")
     }),
-    query: z26.object({
-      versionId: z26.string().optional()
+    query: z28.object({
+      versionId: z28.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z26.undefined(),
+      302: z28.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -4373,8 +4599,8 @@ async function getUsage(options) {
 }
 
 // src/lib/domain/yaml-validator.ts
-import { z as z27 } from "zod";
-var cliAgentNameSchema = z27.string().min(3, "Agent name must be at least 3 characters").max(64, "Agent name must be 64 characters or less").regex(
+import { z as z29 } from "zod";
+var cliAgentNameSchema = z29.string().min(3, "Agent name must be at least 3 characters").max(64, "Agent name must be 64 characters or less").regex(
   /^[a-zA-Z0-9]([a-zA-Z0-9-]{0,62}[a-zA-Z0-9])?$/,
   "Agent name must start and end with letter or number, and contain only letters, numbers, and hyphens"
 );
@@ -4389,7 +4615,7 @@ var cliAgentDefinitionSchema = agentDefinitionSchema.superRefine(
         const skillUrl = agent.skills[i];
         if (skillUrl && !validateGitHubTreeUrl(skillUrl)) {
           ctx.addIssue({
-            code: z27.ZodIssueCode.custom,
+            code: z29.ZodIssueCode.custom,
             message: `Invalid skill URL: ${skillUrl}. Expected format: https://github.com/{owner}/{repo}/tree/{branch}/{path}`,
             path: ["skills", i]
           });
@@ -4398,15 +4624,15 @@ var cliAgentDefinitionSchema = agentDefinitionSchema.superRefine(
     }
   }
 );
-var cliComposeSchema = z27.object({
-  version: z27.string().min(1, "Missing config.version"),
-  agents: z27.record(cliAgentNameSchema, cliAgentDefinitionSchema),
-  volumes: z27.record(z27.string(), volumeConfigSchema).optional()
+var cliComposeSchema = z29.object({
+  version: z29.string().min(1, "Missing config.version"),
+  agents: z29.record(cliAgentNameSchema, cliAgentDefinitionSchema),
+  volumes: z29.record(z29.string(), volumeConfigSchema).optional()
 }).superRefine((config, ctx) => {
   const agentKeys = Object.keys(config.agents);
   if (agentKeys.length === 0) {
     ctx.addIssue({
-      code: z27.ZodIssueCode.custom,
+      code: z29.ZodIssueCode.custom,
       message: "agents must have at least one agent defined",
       path: ["agents"]
     });
@@ -4414,7 +4640,7 @@ var cliComposeSchema = z27.object({
   }
   if (agentKeys.length > 1) {
     ctx.addIssue({
-      code: z27.ZodIssueCode.custom,
+      code: z29.ZodIssueCode.custom,
       message: "Multiple agents not supported yet. Only one agent allowed.",
       path: ["agents"]
     });
@@ -4426,7 +4652,7 @@ var cliComposeSchema = z27.object({
   if (agentVolumes && agentVolumes.length > 0) {
     if (!config.volumes) {
       ctx.addIssue({
-        code: z27.ZodIssueCode.custom,
+        code: z29.ZodIssueCode.custom,
         message: "Agent references volumes but no volumes section defined. Each volume must have explicit name and version.",
         path: ["volumes"]
       });
@@ -4436,7 +4662,7 @@ var cliComposeSchema = z27.object({
       const parts = volDeclaration.split(":");
       if (parts.length !== 2) {
         ctx.addIssue({
-          code: z27.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: `Invalid volume declaration: ${volDeclaration}. Expected format: volume-key:/mount/path`,
           path: ["agents", agentName, "volumes"]
         });
@@ -4445,7 +4671,7 @@ var cliComposeSchema = z27.object({
       const volumeKey = parts[0].trim();
       if (!config.volumes[volumeKey]) {
         ctx.addIssue({
-          code: z27.ZodIssueCode.custom,
+          code: z29.ZodIssueCode.custom,
           message: `Volume "${volumeKey}" is not defined in volumes section. Each volume must have explicit name and version.`,
           path: ["volumes", volumeKey]
         });
@@ -5614,7 +5840,7 @@ async function finalizeCompose(config, agent, variables, options) {
     );
   }
   if (options.autoUpdate !== false) {
-    await silentUpgradeAfterCommand("9.22.0");
+    await silentUpgradeAfterCommand("9.24.0");
   }
   return result;
 }
@@ -6077,8 +6303,8 @@ var EventRenderer = class _EventRenderer {
   /**
    * Format timestamp for display (without milliseconds, matching metrics format)
    */
-  static formatTimestamp(timestamp) {
-    return timestamp.toISOString().replace(/\.\d{3}Z$/, "Z");
+  static formatTimestamp(timestamp2) {
+    return timestamp2.toISOString().replace(/\.\d{3}Z$/, "Z");
   }
   /**
    * Render a parsed event to console
@@ -6551,9 +6777,9 @@ var CodexEventParser = class {
       }
     }
     if (itemType === "file_change" && item.changes && item.changes.length > 0) {
-      const changes = item.changes.map((c23) => {
-        const action = c23.kind === "add" ? "Created" : c23.kind === "modify" ? "Modified" : "Deleted";
-        return `${action}: ${c23.path}`;
+      const changes = item.changes.map((c25) => {
+        const action = c25.kind === "add" ? "Created" : c25.kind === "modify" ? "Modified" : "Deleted";
+        return `${action}: ${c25.path}`;
       }).join("\n");
       return {
         type: "text",
@@ -6707,9 +6933,9 @@ var CodexEventRenderer = class {
       return;
     }
     if (itemType === "file_change" && item.changes && item.changes.length > 0) {
-      const summary = item.changes.map((c23) => {
-        const icon = c23.kind === "add" ? "+" : c23.kind === "delete" ? "-" : "~";
-        return `${icon}${c23.path}`;
+      const summary = item.changes.map((c25) => {
+        const icon = c25.kind === "add" ? "+" : c25.kind === "delete" ? "-" : "~";
+        return `${icon}${c25.path}`;
       }).join(", ");
       console.log(chalk7.green("[files]") + ` ${summary}`);
       return;
@@ -8056,7 +8282,7 @@ var mainRunCommand = new Command8().name("run").description("Run an agent").argu
       }
       showNextSteps(result);
       if (options.autoUpdate !== false) {
-        await silentUpgradeAfterCommand("9.22.0");
+        await silentUpgradeAfterCommand("9.24.0");
       }
     } catch (error) {
       handleRunError(error, identifier);
@@ -9563,7 +9789,7 @@ var cookAction = new Command27().name("cook").description("Quick start: prepare,
 ).option("-y, --yes", "Skip confirmation prompts").option("-v, --verbose", "Show full tool inputs and outputs").addOption(new Option5("--debug-no-mock-claude").hideHelp()).addOption(new Option5("--no-auto-update").hideHelp()).action(
   async (prompt, options) => {
     if (options.autoUpdate !== false) {
-      const shouldExit = await checkAndUpgrade("9.22.0", prompt);
+      const shouldExit = await checkAndUpgrade("9.24.0", prompt);
       if (shouldExit) {
         process.exit(0);
       }
@@ -9763,11 +9989,11 @@ function parseTime(timeStr) {
     return parseRelativeTime(value, unit);
   }
   if (/^\d+$/.test(timeStr)) {
-    const timestamp = parseInt(timeStr, 10);
-    if (timestamp < 1e10) {
-      return timestamp * 1e3;
+    const timestamp2 = parseInt(timeStr, 10);
+    if (timestamp2 < 1e10) {
+      return timestamp2 * 1e3;
     }
-    return timestamp;
+    return timestamp2;
   }
   const date = new Date(timeStr);
   if (!isNaN(date.getTime())) {
@@ -10278,7 +10504,7 @@ var listCommand4 = new Command36().name("list").alias("ls").description("List al
       );
       return;
     }
-    const nameWidth = Math.max(4, ...data.composes.map((c23) => c23.name.length));
+    const nameWidth = Math.max(4, ...data.composes.map((c25) => c25.name.length));
     const header = ["NAME".padEnd(nameWidth), "VERSION", "UPDATED"].join(
       "  "
     );
@@ -11252,7 +11478,7 @@ async function gatherFrequency(optionFrequency, existingFrequency) {
     );
     process.exit(1);
   }
-  const defaultIndex = existingFrequency ? FREQUENCY_CHOICES.findIndex((c23) => c23.value === existingFrequency) : 0;
+  const defaultIndex = existingFrequency ? FREQUENCY_CHOICES.findIndex((c25) => c25.value === existingFrequency) : 0;
   frequency = await promptSelect(
     "Schedule frequency",
     FREQUENCY_CHOICES,
@@ -11281,7 +11507,7 @@ async function gatherDay(frequency, optionDay, existingDay) {
     process.exit(1);
   }
   if (frequency === "weekly") {
-    const defaultDayIndex = existingDay !== void 0 ? DAY_OF_WEEK_CHOICES.findIndex((c23) => c23.value === existingDay) : 0;
+    const defaultDayIndex = existingDay !== void 0 ? DAY_OF_WEEK_CHOICES.findIndex((c25) => c25.value === existingDay) : 0;
     const day2 = await promptSelect(
       "Day of week",
       DAY_OF_WEEK_CHOICES,
@@ -13040,26 +13266,145 @@ var setDefaultCommand = new Command64().name("set-default").description("Set a m
 // src/commands/model-provider/index.ts
 var modelProviderCommand = new Command65().name("model-provider").description("Manage model providers for agent runs").addCommand(listCommand8).addCommand(setupCommand2).addCommand(deleteCommand4).addCommand(setDefaultCommand);
 
-// src/commands/onboard/index.ts
+// src/commands/connector/index.ts
+import { Command as Command67 } from "commander";
+
+// src/commands/connector/connect.ts
 import { Command as Command66 } from "commander";
-import chalk66 from "chalk";
+import chalk63 from "chalk";
+import { initClient as initClient11 } from "@ts-rest/core";
+function delay2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function getHeaders2() {
+  const token = await getToken();
+  if (!token) {
+    throw new Error("Not authenticated. Run: vm0 auth login");
+  }
+  const headers = {
+    Authorization: `Bearer ${token}`
+  };
+  const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+  if (bypassSecret) {
+    headers["x-vercel-protection-bypass"] = bypassSecret;
+  }
+  return headers;
+}
+var connectCommand = new Command66().name("connect").description("Connect a third-party service (e.g., GitHub)").argument("<type>", "Connector type (e.g., github)").action(async (type) => {
+  const parseResult = connectorTypeSchema.safeParse(type);
+  if (!parseResult.success) {
+    console.error(chalk63.red(`Unknown connector type: ${type}`));
+    console.error("Available connectors: github");
+    process.exit(1);
+  }
+  const connectorType = parseResult.data;
+  const apiUrl = await getApiUrl();
+  const headers = await getHeaders2();
+  console.log(`Connecting ${chalk63.cyan(type)}...`);
+  const sessionsClient = initClient11(connectorSessionsContract, {
+    baseUrl: apiUrl,
+    baseHeaders: headers,
+    jsonQuery: true
+  });
+  const createResult = await sessionsClient.create({
+    params: { type: connectorType },
+    body: {}
+  });
+  if (createResult.status !== 200) {
+    const errorBody = createResult.body;
+    console.error(
+      chalk63.red(`Failed to create session: ${errorBody.error?.message}`)
+    );
+    process.exit(1);
+  }
+  const session = createResult.body;
+  const verificationUrl = `${apiUrl}${session.verificationUrl}`;
+  console.log(chalk63.green("\nSession created"));
+  console.log(chalk63.cyan(`
+To connect, visit: ${verificationUrl}`));
+  console.log(`Session code: ${chalk63.bold(session.code)}`);
+  console.log(
+    `
+The session expires in ${Math.floor(session.expiresIn / 60)} minutes.`
+  );
+  console.log("\nWaiting for authorization...");
+  const sessionClient = initClient11(connectorSessionByIdContract, {
+    baseUrl: apiUrl,
+    baseHeaders: headers,
+    jsonQuery: true
+  });
+  const startTime = Date.now();
+  const maxWaitTime = session.expiresIn * 1e3;
+  const pollInterval = (session.interval || 5) * 1e3;
+  let isFirstPoll = true;
+  while (Date.now() - startTime < maxWaitTime) {
+    if (!isFirstPoll) {
+      await delay2(pollInterval);
+    }
+    isFirstPoll = false;
+    const statusResult = await sessionClient.get({
+      params: { type: connectorType, sessionId: session.id }
+    });
+    if (statusResult.status !== 200) {
+      const errorBody = statusResult.body;
+      console.error(
+        chalk63.red(`
+Failed to check status: ${errorBody.error?.message}`)
+      );
+      process.exit(1);
+    }
+    const status = statusResult.body;
+    switch (status.status) {
+      case "complete":
+        console.log(chalk63.green(`
+
+${type} connected successfully!`));
+        return;
+      case "expired":
+        console.log(chalk63.red("\nSession expired. Please try again."));
+        process.exit(1);
+        break;
+      case "error":
+        console.log(
+          chalk63.red(
+            `
+Connection failed: ${status.errorMessage || "Unknown error"}`
+          )
+        );
+        process.exit(1);
+        break;
+      case "pending":
+        process.stdout.write(chalk63.dim("."));
+        break;
+    }
+  }
+  console.log(chalk63.red("\nSession timed out. Please try again."));
+  process.exit(1);
+});
+
+// src/commands/connector/index.ts
+var connectorCommand = new Command67().name("connector").description("Manage third-party service connections").addCommand(connectCommand);
+
+// src/commands/onboard/index.ts
+import { Command as Command68 } from "commander";
+import chalk67 from "chalk";
 import { mkdir as mkdir8 } from "fs/promises";
 import { existsSync as existsSync11 } from "fs";
 
 // src/lib/ui/welcome-box.ts
-import chalk63 from "chalk";
+import chalk64 from "chalk";
 var gradientColors = [
-  chalk63.hex("#FFAB5E"),
+  chalk64.hex("#FFAB5E"),
   // Line 1 - lightest
-  chalk63.hex("#FF9642"),
+  chalk64.hex("#FF9642"),
   // Line 2
-  chalk63.hex("#FF8228"),
+  chalk64.hex("#FF8228"),
   // Line 3
-  chalk63.hex("#FF6D0A"),
+  chalk64.hex("#FF6D0A"),
   // Line 4
-  chalk63.hex("#E85D00"),
+  chalk64.hex("#E85D00"),
   // Line 5
-  chalk63.hex("#CC4E00")
+  chalk64.hex("#CC4E00")
   // Line 6 - darkest
 ];
 var vm0LogoLines = [
@@ -13081,15 +13426,15 @@ function renderVm0Banner() {
 function renderOnboardWelcome() {
   renderVm0Banner();
   console.log(`  Build agentic workflows using natural language.`);
-  console.log(`  ${chalk63.dim("Currently in beta, enjoy it free.")}`);
+  console.log(`  ${chalk64.dim("Currently in beta, enjoy it free.")}`);
   console.log(
-    `  ${chalk63.dim("Star us on GitHub: https://github.com/vm0-ai/vm0")}`
+    `  ${chalk64.dim("Star us on GitHub: https://github.com/vm0-ai/vm0")}`
   );
   console.log();
 }
 
 // src/lib/ui/step-runner.ts
-import chalk64 from "chalk";
+import chalk65 from "chalk";
 function createStepRunner(options = true) {
   const opts = typeof options === "boolean" ? { interactive: options } : options;
   const interactive = opts.interactive ?? true;
@@ -13104,25 +13449,25 @@ function createStepRunner(options = true) {
     }
     for (const [i, step] of completedSteps.entries()) {
       if (step.failed) {
-        console.log(chalk64.red(`\u2717 ${step.label}`));
+        console.log(chalk65.red(`\u2717 ${step.label}`));
       } else {
-        console.log(chalk64.green(`\u25CF ${step.label}`));
+        console.log(chalk65.green(`\u25CF ${step.label}`));
       }
       const isLastStep = i === completedSteps.length - 1;
       if (!isLastStep || !isFinal) {
-        console.log(chalk64.dim("\u2502"));
+        console.log(chalk65.dim("\u2502"));
       }
     }
   }
   async function executeStep(label, fn, isFinal) {
     let stepFailed = false;
-    console.log(chalk64.yellow(`\u25CB ${label}`));
+    console.log(chalk65.yellow(`\u25CB ${label}`));
     const ctx = {
       connector() {
-        console.log(chalk64.dim("\u2502"));
+        console.log(chalk65.dim("\u2502"));
       },
       detail(message) {
-        console.log(`${chalk64.dim("\u2502")} ${message}`);
+        console.log(`${chalk65.dim("\u2502")} ${message}`);
       },
       async prompt(promptFn) {
         return await promptFn();
@@ -13139,12 +13484,12 @@ function createStepRunner(options = true) {
         redrawCompletedSteps(isFinal);
       } else {
         if (stepFailed) {
-          console.log(chalk64.red(`\u2717 ${label}`));
+          console.log(chalk65.red(`\u2717 ${label}`));
         } else {
-          console.log(chalk64.green(`\u25CF ${label}`));
+          console.log(chalk65.green(`\u25CF ${label}`));
         }
         if (!isFinal) {
-          console.log(chalk64.dim("\u2502"));
+          console.log(chalk65.dim("\u2502"));
         }
       }
     }
@@ -13189,7 +13534,7 @@ async function exchangeToken2(apiUrl, deviceCode) {
   });
   return response.json();
 }
-function delay2(ms) {
+function delay3(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function isAuthenticated() {
@@ -13220,7 +13565,7 @@ async function pollForToken(apiUrl, deviceAuth, callbacks) {
   let isFirstPoll = true;
   while (Date.now() - startTime < maxWaitTime) {
     if (!isFirstPoll) {
-      await delay2(pollInterval);
+      await delay3(pollInterval);
     }
     isFirstPoll = false;
     const tokenResult = await exchangeToken2(apiUrl, deviceAuth.device_code);
@@ -13301,7 +13646,7 @@ async function setupModelProvider(type, secret, options) {
 
 // src/lib/domain/onboard/claude-setup.ts
 import { spawn as spawn3 } from "child_process";
-import chalk65 from "chalk";
+import chalk66 from "chalk";
 var MARKETPLACE_NAME = "vm0-skills";
 var MARKETPLACE_REPO = "vm0-ai/vm0-skills";
 var PLUGIN_ID = "vm0@vm0-skills";
@@ -13338,12 +13683,12 @@ async function runClaudeCommand(args, cwd) {
 }
 function handlePluginError(error, context) {
   const displayContext = context ?? "Claude plugin";
-  console.error(chalk65.red(`Failed to install ${displayContext}`));
+  console.error(chalk66.red(`Failed to install ${displayContext}`));
   if (error instanceof Error) {
-    console.error(chalk65.red(error.message));
+    console.error(chalk66.red(error.message));
   }
   console.error(
-    chalk65.dim("Please ensure Claude CLI is installed and accessible.")
+    chalk66.dim("Please ensure Claude CLI is installed and accessible.")
   );
   process.exit(1);
 }
@@ -13386,7 +13731,7 @@ async function updateMarketplace() {
   ]);
   if (!result.success) {
     console.warn(
-      chalk65.yellow(
+      chalk66.yellow(
         `Warning: Could not update marketplace: ${result.error ?? "unknown error"}`
       )
     );
@@ -13424,7 +13769,7 @@ async function handleAuthentication(ctx) {
       return;
     }
     if (!ctx.interactive) {
-      console.error(chalk66.red("Error: Not authenticated"));
+      console.error(chalk67.red("Error: Not authenticated"));
       console.error("Run 'vm0 auth login' first or set VM0_TOKEN");
       process.exit(1);
     }
@@ -13432,16 +13777,16 @@ async function handleAuthentication(ctx) {
       onInitiating: () => {
       },
       onDeviceCodeReady: (url, code, expiresIn) => {
-        step.detail(`Copy code: ${chalk66.cyan.bold(code)}`);
-        step.detail(`Open: ${chalk66.cyan(url)}`);
-        step.detail(chalk66.dim(`Expires in ${expiresIn} minutes`));
+        step.detail(`Copy code: ${chalk67.cyan.bold(code)}`);
+        step.detail(`Open: ${chalk67.cyan(url)}`);
+        step.detail(chalk67.dim(`Expires in ${expiresIn} minutes`));
       },
       onPolling: () => {
       },
       onSuccess: () => {
       },
       onError: (error) => {
-        console.error(chalk66.red(`
+        console.error(chalk67.red(`
 ${error.message}`));
         process.exit(1);
       }
@@ -13455,7 +13800,7 @@ async function handleModelProvider(ctx) {
       return;
     }
     if (!ctx.interactive) {
-      console.error(chalk66.red("Error: No model provider configured"));
+      console.error(chalk67.red("Error: No model provider configured"));
       console.error("Run 'vm0 model-provider setup' first");
       process.exit(1);
     }
@@ -13464,26 +13809,26 @@ async function handleModelProvider(ctx) {
     const providerType = await step.prompt(
       () => promptSelect(
         "Select provider type:",
-        choices.map((c23) => ({
-          title: c23.label,
-          value: c23.type
+        choices.map((c25) => ({
+          title: c25.label,
+          value: c25.type
         }))
       )
     );
     if (!providerType) {
       process.exit(0);
     }
-    const selectedChoice = choices.find((c23) => c23.type === providerType);
+    const selectedChoice = choices.find((c25) => c25.type === providerType);
     if (selectedChoice?.helpText) {
       for (const line of selectedChoice.helpText.split("\n")) {
-        step.detail(chalk66.dim(line));
+        step.detail(chalk67.dim(line));
       }
     }
     const secret = await step.prompt(
       () => promptPassword(`Enter your ${selectedChoice?.secretLabel ?? "secret"}:`)
     );
     if (!secret) {
-      console.log(chalk66.dim("Cancelled"));
+      console.log(chalk67.dim("Cancelled"));
       process.exit(0);
     }
     let selectedModel;
@@ -13502,7 +13847,7 @@ async function handleModelProvider(ctx) {
         () => promptSelect("Select model:", modelChoices)
       );
       if (modelSelection === void 0) {
-        console.log(chalk66.dim("Cancelled"));
+        console.log(chalk67.dim("Cancelled"));
         process.exit(0);
       }
       selectedModel = modelSelection === "" ? void 0 : modelSelection;
@@ -13512,7 +13857,7 @@ async function handleModelProvider(ctx) {
     });
     const modelNote = result.provider.selectedModel ? ` with model: ${result.provider.selectedModel}` : "";
     step.detail(
-      chalk66.green(
+      chalk67.green(
         `${providerType} ${result.created ? "created" : "updated"}${result.isDefault ? ` (default for ${result.framework})` : ""}${modelNote}`
       )
     );
@@ -13543,7 +13888,7 @@ async function handleAgentCreation(ctx) {
         agentName = inputName;
         if (existsSync11(agentName)) {
           step.detail(
-            chalk66.yellow(`${agentName}/ already exists, choose another name`)
+            chalk67.yellow(`${agentName}/ already exists, choose another name`)
           );
         } else {
           folderExists = false;
@@ -13552,22 +13897,22 @@ async function handleAgentCreation(ctx) {
     } else {
       if (!validateAgentName(agentName)) {
         console.error(
-          chalk66.red(
+          chalk67.red(
             "Invalid agent name: must be 3-64 chars, alphanumeric + hyphens"
           )
         );
         process.exit(1);
       }
       if (existsSync11(agentName)) {
-        console.error(chalk66.red(`${agentName}/ already exists`));
+        console.error(chalk67.red(`${agentName}/ already exists`));
         console.log();
         console.log("Remove it first or choose a different name:");
-        console.log(chalk66.cyan(`  rm -rf ${agentName}`));
+        console.log(chalk67.cyan(`  rm -rf ${agentName}`));
         process.exit(1);
       }
     }
     await mkdir8(agentName, { recursive: true });
-    step.detail(chalk66.green(`Created ${agentName}/`));
+    step.detail(chalk67.green(`Created ${agentName}/`));
   });
   return agentName;
 }
@@ -13583,7 +13928,7 @@ async function handlePluginInstallation(ctx, agentName) {
       shouldInstall = confirmed ?? true;
     }
     if (!shouldInstall) {
-      step.detail(chalk66.dim("Skipped"));
+      step.detail(chalk67.dim("Skipped"));
       return;
     }
     const scope = "project";
@@ -13591,7 +13936,7 @@ async function handlePluginInstallation(ctx, agentName) {
       const agentDir = `${process.cwd()}/${agentName}`;
       const result = await installVm0Plugin(scope, agentDir);
       step.detail(
-        chalk66.green(`Installed ${result.pluginId} (scope: ${result.scope})`)
+        chalk67.green(`Installed ${result.pluginId} (scope: ${result.scope})`)
       );
       pluginInstalled = true;
     } catch (error) {
@@ -13602,18 +13947,18 @@ async function handlePluginInstallation(ctx, agentName) {
 }
 function printNextSteps(agentName, pluginInstalled) {
   console.log();
-  console.log(chalk66.bold("Next step:"));
+  console.log(chalk67.bold("Next step:"));
   console.log();
   if (pluginInstalled) {
     console.log(
-      `  ${chalk66.cyan(`cd ${agentName} && claude "/${PRIMARY_SKILL_NAME} let's build an agent"`)}`
+      `  ${chalk67.cyan(`cd ${agentName} && claude "/${PRIMARY_SKILL_NAME} let's build an agent"`)}`
     );
   } else {
-    console.log(`  ${chalk66.cyan(`cd ${agentName} && vm0 init`)}`);
+    console.log(`  ${chalk67.cyan(`cd ${agentName} && vm0 init`)}`);
   }
   console.log();
 }
-var onboardCommand = new Command66().name("onboard").description("Guided setup for new VM0 users").option("-y, --yes", "Skip confirmation prompts").option("--name <name>", `Agent name (default: ${DEFAULT_AGENT_NAME})`).action(async (options) => {
+var onboardCommand = new Command68().name("onboard").description("Guided setup for new VM0 users").option("-y, --yes", "Skip confirmation prompts").option("--name <name>", `Agent name (default: ${DEFAULT_AGENT_NAME})`).action(async (options) => {
   const interactive = isInteractive();
   if (interactive) {
     process.stdout.write("\x1B[2J\x1B[H");
@@ -13636,15 +13981,15 @@ var onboardCommand = new Command66().name("onboard").description("Guided setup f
 });
 
 // src/commands/setup-claude/index.ts
-import { Command as Command67 } from "commander";
-import chalk67 from "chalk";
-var setupClaudeCommand = new Command67().name("setup-claude").description("Install VM0 Claude Plugin").option("--agent-dir <dir>", "Agent directory to run install in").option("--scope <scope>", "Installation scope (user or project)", "project").action(async (options) => {
-  console.log(chalk67.dim("Installing VM0 Claude Plugin..."));
+import { Command as Command69 } from "commander";
+import chalk68 from "chalk";
+var setupClaudeCommand = new Command69().name("setup-claude").description("Install VM0 Claude Plugin").option("--agent-dir <dir>", "Agent directory to run install in").option("--scope <scope>", "Installation scope (user or project)", "project").action(async (options) => {
+  console.log(chalk68.dim("Installing VM0 Claude Plugin..."));
   const scope = options.scope === "user" ? "user" : "project";
   try {
     const result = await installVm0Plugin(scope, options.agentDir);
     console.log(
-      chalk67.green(`\u2713 Installed ${result.pluginId} (scope: ${result.scope})`)
+      chalk68.green(`\u2713 Installed ${result.pluginId} (scope: ${result.scope})`)
     );
   } catch (error) {
     handlePluginError(error);
@@ -13653,15 +13998,174 @@ var setupClaudeCommand = new Command67().name("setup-claude").description("Insta
   console.log("Next step:");
   const cdPrefix = options.agentDir ? `cd ${options.agentDir} && ` : "";
   console.log(
-    chalk67.cyan(
+    chalk68.cyan(
       `  ${cdPrefix}claude "/${PRIMARY_SKILL_NAME} let's build a workflow"`
     )
   );
 });
 
+// src/commands/dev-tool/index.ts
+import { Command as Command71 } from "commander";
+
+// src/commands/dev-tool/compose.ts
+import { Command as Command70 } from "commander";
+import chalk69 from "chalk";
+import { initClient as initClient12 } from "@ts-rest/core";
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function timestamp() {
+  return (/* @__PURE__ */ new Date()).toLocaleTimeString("en-US", { hour12: false });
+}
+async function createComposeJob(githubUrl, overwrite) {
+  const config = await getClientConfig();
+  const client = initClient12(composeJobsMainContract, config);
+  const result = await client.create({
+    body: { githubUrl, overwrite }
+  });
+  if (result.status === 200 || result.status === 201) {
+    return {
+      jobId: result.body.jobId,
+      status: result.body.status
+    };
+  }
+  if (result.status === 400 || result.status === 401) {
+    throw new Error(result.body.error.message);
+  }
+  throw new Error(`Unexpected response: ${result.status}`);
+}
+async function getComposeJobStatus(jobId) {
+  const config = await getClientConfig();
+  const client = initClient12(composeJobsByIdContract, config);
+  const result = await client.getById({
+    params: { jobId }
+  });
+  if (result.status === 200) {
+    return {
+      status: result.body.status,
+      result: result.body.result,
+      error: result.body.error
+    };
+  }
+  if (result.status === 404) {
+    throw new Error(`Job not found: ${jobId}`);
+  }
+  if (result.status === 401) {
+    throw new Error(result.body.error.message);
+  }
+  throw new Error(`Unexpected response: ${result.status}`);
+}
+async function pollUntilComplete(jobId, intervalMs, timeoutMs, jsonMode) {
+  const startTime = Date.now();
+  while (Date.now() - startTime < timeoutMs) {
+    const job = await getComposeJobStatus(jobId);
+    if (!jsonMode) {
+      console.log(
+        chalk69.dim(`[${timestamp()}] Polling... status=${job.status}`)
+      );
+    }
+    if (job.status === "completed" || job.status === "failed") {
+      return job;
+    }
+    await sleep2(intervalMs);
+  }
+  throw new Error(`Timeout after ${timeoutMs / 1e3} seconds`);
+}
+var composeCommand2 = new Command70().name("compose").description("Test server-side GitHub compose API").argument("<github-url>", "GitHub URL to compose from").option("--overwrite", "Overwrite existing compose", false).option(
+  "--interval <seconds>",
+  "Polling interval in seconds",
+  (v) => parseInt(v, 10),
+  5
+).option(
+  "--timeout <seconds>",
+  "Maximum wait time in seconds",
+  (v) => parseInt(v, 10),
+  300
+).option("--json", "Output result as JSON").action(
+  async (githubUrl, options) => {
+    const intervalMs = options.interval * 1e3;
+    const timeoutMs = options.timeout * 1e3;
+    try {
+      if (!options.json) {
+        console.log("Creating compose job...");
+      }
+      const { jobId, status: initialStatus } = await createComposeJob(
+        githubUrl,
+        options.overwrite
+      );
+      if (!options.json) {
+        console.log(`Job ID: ${chalk69.cyan(jobId)}`);
+        console.log();
+      }
+      if (initialStatus === "completed" || initialStatus === "failed") {
+        const finalJob2 = await getComposeJobStatus(jobId);
+        if (options.json) {
+          console.log(JSON.stringify(finalJob2, null, 2));
+        } else {
+          displayResult(finalJob2);
+        }
+        process.exit(finalJob2.status === "completed" ? 0 : 1);
+      }
+      const finalJob = await pollUntilComplete(
+        jobId,
+        intervalMs,
+        timeoutMs,
+        !!options.json
+      );
+      if (options.json) {
+        console.log(JSON.stringify(finalJob, null, 2));
+      } else {
+        console.log();
+        displayResult(finalJob);
+      }
+      process.exit(finalJob.status === "completed" ? 0 : 1);
+    } catch (error) {
+      if (options.json) {
+        console.log(
+          JSON.stringify({
+            error: error instanceof Error ? error.message : String(error)
+          })
+        );
+      } else {
+        console.error(
+          chalk69.red(
+            `\u2717 ${error instanceof Error ? error.message : String(error)}`
+          )
+        );
+      }
+      process.exit(1);
+    }
+  }
+);
+function displayResult(job) {
+  if (job.status === "completed" && job.result) {
+    console.log(chalk69.green("\u2713 Compose completed!"));
+    console.log(`  Compose ID: ${chalk69.cyan(job.result.composeId)}`);
+    console.log(`  Name: ${chalk69.cyan(job.result.composeName)}`);
+    console.log(`  Version: ${chalk69.cyan(job.result.versionId.slice(0, 8))}`);
+    if (job.result.warnings.length > 0) {
+      console.log();
+      console.log(chalk69.yellow("  Warnings:"));
+      for (const warning of job.result.warnings) {
+        console.log(chalk69.yellow(`    - ${warning}`));
+      }
+    }
+  } else if (job.status === "failed") {
+    console.log(chalk69.red("\u2717 Compose failed!"));
+    if (job.error) {
+      console.log(`  Error: ${chalk69.red(job.error)}`);
+    }
+  } else {
+    console.log(`Status: ${job.status}`);
+  }
+}
+
+// src/commands/dev-tool/index.ts
+var devToolCommand = new Command71().name("dev-tool").description("Developer tools for testing and debugging").addCommand(composeCommand2);
+
 // src/index.ts
-var program = new Command68();
-program.name("vm0").description("VM0 CLI - Build and run agents with natural language").version("9.22.0");
+var program = new Command72();
+program.name("vm0").description("VM0 CLI - Build and run agents with natural language").version("9.24.0");
 program.addCommand(authCommand);
 program.addCommand(infoCommand);
 program.addCommand(composeCommand);
@@ -13678,8 +14182,10 @@ program.addCommand(usageCommand);
 program.addCommand(secretCommand);
 program.addCommand(variableCommand);
 program.addCommand(modelProviderCommand);
+program.addCommand(connectorCommand);
 program.addCommand(onboardCommand);
 program.addCommand(setupClaudeCommand);
+program.addCommand(devToolCommand, { hidden: true });
 if (process.argv[1]?.endsWith("index.js") || process.argv[1]?.endsWith("index.ts") || process.argv[1]?.endsWith("vm0")) {
   program.parse();
 }