@vm0/cli 9.29.5 → 9.30.1

package/index.js

@@ -45,7 +45,7 @@ if (DSN) {
   Sentry.init({
     dsn: DSN,
     environment: process.env.SENTRY_ENVIRONMENT ?? "production",
-    release: "9.29.5",
+    release: "9.30.1",
     sendDefaultPii: false,
     tracesSampleRate: 0,
     shutdownTimeout: 500,
@@ -64,7 +64,7 @@ if (DSN) {
     }
   });
   Sentry.setContext("cli", {
-    version: "9.29.5",
+    version: "9.30.1",
     command: process.argv.slice(2).join(" ")
   });
   Sentry.setContext("runtime", {
@@ -82,7 +82,6 @@ import { Command as Command5 } from "commander";
 
 // src/commands/auth/login.ts
 import { Command } from "commander";
-import chalk2 from "chalk";
 
 // src/lib/api/auth.ts
 import chalk from "chalk";
@@ -265,23 +264,83 @@ async function setupToken() {
   );
 }
 
-// src/commands/auth/login.ts
-var loginCommand = new Command().name("login").description("Log in to VM0 (use VM0_API_URL env var to set API URL)").action(async () => {
-  try {
-    await authenticate();
-  } catch (error) {
-    if (error instanceof Error) {
-      console.error(chalk2.red(`\u2717 Login failed`));
-      console.error(chalk2.dim(`  ${error.message}`));
-      if (error.cause instanceof Error) {
+// src/lib/command/with-error-handler.ts
+import chalk2 from "chalk";
+
+// src/lib/api/core/client-factory.ts
+var ApiRequestError = class extends Error {
+  constructor(message, code, status) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.name = "ApiRequestError";
+  }
+};
+async function getHeaders() {
+  const token = await getToken();
+  if (!token) {
+    throw new ApiRequestError("Not authenticated", "UNAUTHORIZED", 401);
+  }
+  const headers = {
+    Authorization: `Bearer ${token}`
+  };
+  const bypassSecret = process.env.VERCEL_AUTOMATION_BYPASS_SECRET;
+  if (bypassSecret) {
+    headers["x-vercel-protection-bypass"] = bypassSecret;
+  }
+  return headers;
+}
+async function getBaseUrl() {
+  const apiUrl = await getApiUrl();
+  if (!apiUrl) {
+    throw new Error("API URL not configured");
+  }
+  return apiUrl;
+}
+async function getClientConfig() {
+  const baseUrl = await getBaseUrl();
+  const baseHeaders = await getHeaders();
+  return { baseUrl, baseHeaders, jsonQuery: false };
+}
+function handleError(result, defaultMessage) {
+  const errorBody = result.body;
+  const message = errorBody.error?.message || defaultMessage;
+  const code = errorBody.error?.code || "UNKNOWN";
+  throw new ApiRequestError(message, code, result.status);
+}
+
+// src/lib/command/with-error-handler.ts
+function withErrorHandler(fn) {
+  return async (...args) => {
+    try {
+      await fn(...args);
+    } catch (error) {
+      if (error instanceof ApiRequestError) {
+        if (error.code === "UNAUTHORIZED") {
+          console.error(chalk2.red("\u2717 Not authenticated"));
+          console.error(chalk2.dim("  Run: vm0 auth login"));
+        } else {
+          console.error(chalk2.red(`\u2717 ${error.status}: ${error.message}`));
+        }
+      } else if (error instanceof Error) {
+        console.error(chalk2.red(`\u2717 ${error.message}`));
+      } else {
+        console.error(chalk2.red("\u2717 An unexpected error occurred"));
+      }
+      if (error instanceof Error && error.cause instanceof Error) {
         console.error(chalk2.dim(`  Cause: ${error.cause.message}`));
       }
-    } else {
-      console.error(chalk2.red("\u2717 An unexpected error occurred"));
+      process.exit(1);
     }
-    process.exit(1);
-  }
-});
+  };
+}
+
+// src/commands/auth/login.ts
+var loginCommand = new Command().name("login").description("Log in to VM0 (use VM0_API_URL env var to set API URL)").action(
+  withErrorHandler(async () => {
+    await authenticate();
+  })
+);
 
 // src/commands/auth/logout.ts
 import { Command as Command2 } from "commander";
@@ -546,7 +605,7 @@ async function waitForSilentUpgrade(timeout = TIMEOUT_MS) {
 // src/commands/info/index.ts
 var CONFIG_PATH = join2(homedir2(), ".vm0", "config.json");
 var infoCommand = new Command6().name("info").description("Display environment and debug information").action(async () => {
-  console.log(chalk7.bold(`VM0 CLI v${"9.29.5"}`));
+  console.log(chalk7.bold(`VM0 CLI v${"9.30.1"}`));
   console.log();
   const config = await loadConfig();
   const hasEnvToken = !!process.env.VM0_TOKEN;
@@ -3370,74 +3429,36 @@ var platformArtifactDownloadContract = c17.router({
   }
 });
 
-// ../../packages/core/src/contracts/llm.ts
+// ../../packages/core/src/contracts/compose-jobs.ts
 import { z as z22 } from "zod";
 var c18 = initContract();
-var messageRoleSchema = z22.enum(["user", "assistant", "system"]);
-var chatMessageSchema = z22.object({
-  role: messageRoleSchema,
-  content: z22.string()
-});
-var tokenUsageSchema = z22.object({
-  promptTokens: z22.number(),
-  completionTokens: z22.number(),
-  totalTokens: z22.number()
-});
-var llmChatRequestSchema = z22.object({
-  model: z22.string().min(1).optional(),
-  messages: z22.array(chatMessageSchema).min(1, "At least one message is required"),
-  stream: z22.boolean().optional().default(false)
-});
-var llmChatResponseSchema = z22.object({
-  content: z22.string(),
-  model: z22.string(),
-  usage: tokenUsageSchema
-});
-var llmChatContract = c18.router({
-  chat: {
-    method: "POST",
-    path: "/api/llm/chat",
-    body: llmChatRequestSchema,
-    responses: {
-      200: llmChatResponseSchema,
-      400: apiErrorSchema,
-      500: apiErrorSchema,
-      503: apiErrorSchema
-    },
-    summary: "Send a chat completion request to OpenRouter"
-  }
-});
-
-// ../../packages/core/src/contracts/compose-jobs.ts
-import { z as z23 } from "zod";
-var c19 = initContract();
-var composeJobStatusSchema = z23.enum([
+var composeJobStatusSchema = z22.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(),
+var composeJobResultSchema = z22.object({
+  composeId: z22.string(),
+  composeName: z22.string(),
+  versionId: z22.string(),
+  warnings: z22.array(z22.string())
+});
+var createComposeJobRequestSchema = z22.object({
+  githubUrl: z22.string().url().startsWith("https://github.com/"),
+  overwrite: z22.boolean().optional().default(false)
+});
+var composeJobResponseSchema = z22.object({
+  jobId: z22.string(),
   status: composeJobStatusSchema,
-  githubUrl: z23.string(),
+  githubUrl: z22.string(),
   result: composeJobResultSchema.optional(),
-  error: z23.string().optional(),
-  createdAt: z23.string(),
-  startedAt: z23.string().optional(),
-  completedAt: z23.string().optional()
+  error: z22.string().optional(),
+  createdAt: z22.string(),
+  startedAt: z22.string().optional(),
+  completedAt: z22.string().optional()
 });
-var composeJobsMainContract = c19.router({
+var composeJobsMainContract = c18.router({
   /**
    * POST /api/compose/from-github
    * Create a new compose job from GitHub URL
@@ -3457,7 +3478,7 @@ var composeJobsMainContract = c19.router({
     summary: "Create compose job from GitHub URL"
   }
 });
-var composeJobsByIdContract = c19.router({
+var composeJobsByIdContract = c18.router({
   /**
    * GET /api/compose/from-github/:jobId
    * Get compose job status and result
@@ -3466,8 +3487,8 @@ var composeJobsByIdContract = c19.router({
     method: "GET",
     path: "/api/compose/from-github/:jobId",
     headers: authHeadersSchema,
-    pathParams: z23.object({
-      jobId: z23.string().uuid()
+    pathParams: z22.object({
+      jobId: z22.string().uuid()
     }),
     responses: {
       200: composeJobResponseSchema,
@@ -3477,7 +3498,7 @@ var composeJobsByIdContract = c19.router({
     summary: "Get compose job status"
   }
 });
-var webhookComposeCompleteContract = c19.router({
+var webhookComposeCompleteContract = c18.router({
   /**
    * POST /api/webhooks/compose/complete
    * Handle compose job completion from sandbox
@@ -3486,16 +3507,16 @@ var webhookComposeCompleteContract = c19.router({
     method: "POST",
     path: "/api/webhooks/compose/complete",
     headers: authHeadersSchema,
-    body: z23.object({
-      jobId: z23.string().uuid(),
-      success: z23.boolean(),
+    body: z22.object({
+      jobId: z22.string().uuid(),
+      success: z22.boolean(),
       // Result from CLI compose command
       result: composeJobResultSchema.optional(),
-      error: z23.string().optional()
+      error: z22.string().optional()
     }),
     responses: {
-      200: z23.object({
-        success: z23.boolean()
+      200: z22.object({
+        success: z22.boolean()
       }),
       400: apiErrorSchema,
       401: apiErrorSchema,
@@ -3506,8 +3527,8 @@ var webhookComposeCompleteContract = c19.router({
 });
 
 // ../../packages/core/src/contracts/connectors.ts
-import { z as z24 } from "zod";
-var c20 = initContract();
+import { z as z23 } from "zod";
+var c19 = initContract();
 var CONNECTOR_TYPES = {
   github: {
     label: "GitHub",
@@ -3536,7 +3557,7 @@ var CONNECTOR_TYPES = {
     }
   }
 };
-var connectorTypeSchema = z24.enum(["github"]);
+var connectorTypeSchema = z23.enum(["github"]);
 function getConnectorDerivedNames(secretName) {
   const allTypes = Object.keys(CONNECTOR_TYPES);
   for (const type2 of allTypes) {
@@ -3560,21 +3581,21 @@ function getConnectorDerivedNames(secretName) {
   }
   return null;
 }
-var connectorResponseSchema = z24.object({
-  id: z24.string().uuid(),
+var connectorResponseSchema = z23.object({
+  id: z23.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({
+  authMethod: z23.string(),
+  externalId: z23.string().nullable(),
+  externalUsername: z23.string().nullable(),
+  externalEmail: z23.string().nullable(),
+  oauthScopes: z23.array(z23.string()).nullable(),
+  createdAt: z23.string(),
+  updatedAt: z23.string()
+});
+var connectorListResponseSchema = z23.object({
+  connectors: z23.array(connectorResponseSchema)
+});
+var connectorsMainContract = c19.router({
   list: {
     method: "GET",
     path: "/api/connectors",
@@ -3587,12 +3608,12 @@ var connectorsMainContract = c20.router({
     summary: "List all connectors for the authenticated user"
   }
 });
-var connectorsByTypeContract = c20.router({
+var connectorsByTypeContract = c19.router({
   get: {
     method: "GET",
     path: "/api/connectors/:type",
     headers: authHeadersSchema,
-    pathParams: z24.object({
+    pathParams: z23.object({
       type: connectorTypeSchema
     }),
     responses: {
@@ -3607,11 +3628,11 @@ var connectorsByTypeContract = c20.router({
     method: "DELETE",
     path: "/api/connectors/:type",
     headers: authHeadersSchema,
-    pathParams: z24.object({
+    pathParams: z23.object({
       type: connectorTypeSchema
     }),
     responses: {
-      204: c20.noBody(),
+      204: c19.noBody(),
       401: apiErrorSchema,
       404: apiErrorSchema,
       500: apiErrorSchema
@@ -3619,27 +3640,27 @@ var connectorsByTypeContract = c20.router({
     summary: "Disconnect a connector"
   }
 });
-var connectorSessionStatusSchema = z24.enum([
+var connectorSessionStatusSchema = z23.enum([
   "pending",
   "complete",
   "expired",
   "error"
 ]);
-var connectorSessionResponseSchema = z24.object({
-  id: z24.string().uuid(),
-  code: z24.string(),
+var connectorSessionResponseSchema = z23.object({
+  id: z23.string().uuid(),
+  code: z23.string(),
   type: connectorTypeSchema,
   status: connectorSessionStatusSchema,
-  verificationUrl: z24.string(),
-  expiresIn: z24.number(),
-  interval: z24.number(),
-  errorMessage: z24.string().nullable().optional()
+  verificationUrl: z23.string(),
+  expiresIn: z23.number(),
+  interval: z23.number(),
+  errorMessage: z23.string().nullable().optional()
 });
-var connectorSessionStatusResponseSchema = z24.object({
+var connectorSessionStatusResponseSchema = z23.object({
   status: connectorSessionStatusSchema,
-  errorMessage: z24.string().nullable().optional()
+  errorMessage: z23.string().nullable().optional()
 });
-var connectorSessionsContract = c20.router({
+var connectorSessionsContract = c19.router({
   /**
    * POST /api/connectors/:type/sessions
    * Create a new connector session for CLI device flow
@@ -3648,10 +3669,10 @@ var connectorSessionsContract = c20.router({
     method: "POST",
     path: "/api/connectors/:type/sessions",
     headers: authHeadersSchema,
-    pathParams: z24.object({
+    pathParams: z23.object({
       type: connectorTypeSchema
     }),
-    body: z24.object({}).optional(),
+    body: z23.object({}).optional(),
     responses: {
       200: connectorSessionResponseSchema,
       400: apiErrorSchema,
@@ -3661,7 +3682,7 @@ var connectorSessionsContract = c20.router({
     summary: "Create connector session for CLI device flow"
   }
 });
-var connectorSessionByIdContract = c20.router({
+var connectorSessionByIdContract = c19.router({
   /**
    * GET /api/connectors/:type/sessions/:sessionId
    * Get connector session status (for CLI polling)
@@ -3670,9 +3691,9 @@ var connectorSessionByIdContract = c20.router({
     method: "GET",
     path: "/api/connectors/:type/sessions/:sessionId",
     headers: authHeadersSchema,
-    pathParams: z24.object({
+    pathParams: z23.object({
       type: connectorTypeSchema,
-      sessionId: z24.string().uuid()
+      sessionId: z23.string().uuid()
     }),
     responses: {
       200: connectorSessionStatusResponseSchema,
@@ -3686,28 +3707,28 @@ var connectorSessionByIdContract = c20.router({
 });
 
 // ../../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(),
+import { z as z24 } from "zod";
+var c20 = initContract();
+var publicAgentSchema = z24.object({
+  id: z24.string(),
+  name: z24.string(),
+  currentVersionId: z24.string().nullable(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema
 });
-var agentVersionSchema = z25.object({
-  id: z25.string(),
-  agentId: z25.string(),
-  versionNumber: z25.number(),
+var agentVersionSchema = z24.object({
+  id: z24.string(),
+  agentId: z24.string(),
+  versionNumber: z24.number(),
   createdAt: timestampSchema
 });
 var publicAgentDetailSchema = publicAgentSchema;
 var paginatedAgentsSchema = createPaginatedResponseSchema(publicAgentSchema);
 var paginatedAgentVersionsSchema = createPaginatedResponseSchema(agentVersionSchema);
 var agentListQuerySchema = listQuerySchema.extend({
-  name: z25.string().optional()
+  name: z24.string().optional()
 });
-var publicAgentsListContract = c21.router({
+var publicAgentsListContract = c20.router({
   list: {
     method: "GET",
     path: "/v1/agents",
@@ -3722,13 +3743,13 @@ var publicAgentsListContract = c21.router({
     description: "List all agents in the current scope with pagination. Use the `name` query parameter to filter by agent name."
   }
 });
-var publicAgentByIdContract = c21.router({
+var publicAgentByIdContract = c20.router({
   get: {
     method: "GET",
     path: "/v1/agents/:id",
     headers: authHeadersSchema,
-    pathParams: z25.object({
-      id: z25.string().min(1, "Agent ID is required")
+    pathParams: z24.object({
+      id: z24.string().min(1, "Agent ID is required")
     }),
     responses: {
       200: publicAgentDetailSchema,
@@ -3740,13 +3761,13 @@ var publicAgentByIdContract = c21.router({
     description: "Get agent details by ID"
   }
 });
-var publicAgentVersionsContract = c21.router({
+var publicAgentVersionsContract = c20.router({
   list: {
     method: "GET",
     path: "/v1/agents/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z25.object({
-      id: z25.string().min(1, "Agent ID is required")
+    pathParams: z24.object({
+      id: z24.string().min(1, "Agent ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -3761,9 +3782,9 @@ var publicAgentVersionsContract = c21.router({
 });
 
 // ../../packages/core/src/contracts/public/runs.ts
-import { z as z26 } from "zod";
-var c22 = initContract();
-var publicRunStatusSchema = z26.enum([
+import { z as z25 } from "zod";
+var c21 = initContract();
+var publicRunStatusSchema = z25.enum([
   "pending",
   "running",
   "completed",
@@ -3771,54 +3792,54 @@ var publicRunStatusSchema = z26.enum([
   "timeout",
   "cancelled"
 ]);
-var publicRunSchema = z26.object({
-  id: z26.string(),
-  agentId: z26.string(),
-  agentName: z26.string(),
+var publicRunSchema = z25.object({
+  id: z25.string(),
+  agentId: z25.string(),
+  agentName: z25.string(),
   status: publicRunStatusSchema,
-  prompt: z26.string(),
+  prompt: z25.string(),
   createdAt: timestampSchema,
   startedAt: timestampSchema.nullable(),
   completedAt: timestampSchema.nullable()
 });
 var publicRunDetailSchema = publicRunSchema.extend({
-  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()
+  error: z25.string().nullable(),
+  executionTimeMs: z25.number().nullable(),
+  checkpointId: z25.string().nullable(),
+  sessionId: z25.string().nullable(),
+  artifactName: z25.string().nullable(),
+  artifactVersion: z25.string().nullable(),
+  volumes: z25.record(z25.string(), z25.string()).optional()
 });
 var paginatedRunsSchema = createPaginatedResponseSchema(publicRunSchema);
-var createRunRequestSchema = z26.object({
+var createRunRequestSchema = z25.object({
   // Agent identification (one of: agent, agentId, sessionId, checkpointId)
-  agent: z26.string().optional(),
+  agent: z25.string().optional(),
   // Agent name
-  agentId: z26.string().optional(),
+  agentId: z25.string().optional(),
   // Agent ID
-  agentVersion: z26.string().optional(),
+  agentVersion: z25.string().optional(),
   // Version specifier (e.g., "latest", "v1", specific ID)
   // Continue session
-  sessionId: z26.string().optional(),
+  sessionId: z25.string().optional(),
   // Resume from checkpoint
-  checkpointId: z26.string().optional(),
+  checkpointId: z25.string().optional(),
   // Required
-  prompt: z26.string().min(1, "Prompt is required"),
+  prompt: z25.string().min(1, "Prompt is required"),
   // Optional configuration
-  variables: z26.record(z26.string(), z26.string()).optional(),
-  secrets: z26.record(z26.string(), z26.string()).optional(),
-  artifactName: z26.string().optional(),
+  variables: z25.record(z25.string(), z25.string()).optional(),
+  secrets: z25.record(z25.string(), z25.string()).optional(),
+  artifactName: z25.string().optional(),
   // Artifact name to mount
-  artifactVersion: z26.string().optional(),
+  artifactVersion: z25.string().optional(),
   // Artifact version (defaults to latest)
-  volumes: z26.record(z26.string(), z26.string()).optional()
+  volumes: z25.record(z25.string(), z25.string()).optional()
   // volume_name -> version
 });
 var runListQuerySchema = listQuerySchema.extend({
   status: publicRunStatusSchema.optional()
 });
-var publicRunsListContract = c22.router({
+var publicRunsListContract = c21.router({
   list: {
     method: "GET",
     path: "/v1/runs",
@@ -3850,13 +3871,13 @@ var publicRunsListContract = c22.router({
     description: "Create and execute a new agent run. Returns 202 Accepted as runs execute asynchronously."
   }
 });
-var publicRunByIdContract = c22.router({
+var publicRunByIdContract = c21.router({
   get: {
     method: "GET",
     path: "/v1/runs/:id",
     headers: authHeadersSchema,
-    pathParams: z26.object({
-      id: z26.string().min(1, "Run ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Run ID is required")
     }),
     responses: {
       200: publicRunDetailSchema,
@@ -3868,15 +3889,15 @@ var publicRunByIdContract = c22.router({
     description: "Get run details by ID"
   }
 });
-var publicRunCancelContract = c22.router({
+var publicRunCancelContract = c21.router({
   cancel: {
     method: "POST",
     path: "/v1/runs/:id/cancel",
     headers: authHeadersSchema,
-    pathParams: z26.object({
-      id: z26.string().min(1, "Run ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Run ID is required")
     }),
-    body: z26.undefined(),
+    body: z25.undefined(),
     responses: {
       200: publicRunDetailSchema,
       400: publicApiErrorSchema,
@@ -3889,27 +3910,27 @@ var publicRunCancelContract = c22.router({
     description: "Cancel a pending or running execution"
   }
 });
-var logEntrySchema = z26.object({
+var logEntrySchema = z25.object({
   timestamp: timestampSchema,
-  type: z26.enum(["agent", "system", "network"]),
-  level: z26.enum(["debug", "info", "warn", "error"]),
-  message: z26.string(),
-  metadata: z26.record(z26.string(), z26.unknown()).optional()
+  type: z25.enum(["agent", "system", "network"]),
+  level: z25.enum(["debug", "info", "warn", "error"]),
+  message: z25.string(),
+  metadata: z25.record(z25.string(), z25.unknown()).optional()
 });
 var paginatedLogsSchema = createPaginatedResponseSchema(logEntrySchema);
 var logsQuerySchema = listQuerySchema.extend({
-  type: z26.enum(["agent", "system", "network", "all"]).default("all"),
+  type: z25.enum(["agent", "system", "network", "all"]).default("all"),
   since: timestampSchema.optional(),
   until: timestampSchema.optional(),
-  order: z26.enum(["asc", "desc"]).default("asc")
+  order: z25.enum(["asc", "desc"]).default("asc")
 });
-var publicRunLogsContract = c22.router({
+var publicRunLogsContract = c21.router({
   getLogs: {
     method: "GET",
     path: "/v1/runs/:id/logs",
     headers: authHeadersSchema,
-    pathParams: z26.object({
-      id: z26.string().min(1, "Run ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Run ID is required")
     }),
     query: logsQuerySchema,
     responses: {
@@ -3922,30 +3943,30 @@ var publicRunLogsContract = c22.router({
     description: "Get unified logs for a run. Combines agent, system, and network logs."
   }
 });
-var metricPointSchema = z26.object({
+var metricPointSchema = z25.object({
   timestamp: timestampSchema,
-  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),
+  cpuPercent: z25.number(),
+  memoryUsedMb: z25.number(),
+  memoryTotalMb: z25.number(),
+  diskUsedMb: z25.number(),
+  diskTotalMb: z25.number()
+});
+var metricsSummarySchema = z25.object({
+  avgCpuPercent: z25.number(),
+  maxMemoryUsedMb: z25.number(),
+  totalDurationMs: z25.number().nullable()
+});
+var metricsResponseSchema2 = z25.object({
+  data: z25.array(metricPointSchema),
   summary: metricsSummarySchema
 });
-var publicRunMetricsContract = c22.router({
+var publicRunMetricsContract = c21.router({
   getMetrics: {
     method: "GET",
     path: "/v1/runs/:id/metrics",
     headers: authHeadersSchema,
-    pathParams: z26.object({
-      id: z26.string().min(1, "Run ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Run ID is required")
     }),
     responses: {
       200: metricsResponseSchema2,
@@ -3957,7 +3978,7 @@ var publicRunMetricsContract = c22.router({
     description: "Get CPU, memory, and disk metrics for a run"
   }
 });
-var sseEventTypeSchema = z26.enum([
+var sseEventTypeSchema = z25.enum([
   "status",
   // Run status change
   "output",
@@ -3969,26 +3990,26 @@ var sseEventTypeSchema = z26.enum([
   "heartbeat"
   // Keep-alive
 ]);
-var sseEventSchema = z26.object({
+var sseEventSchema = z25.object({
   event: sseEventTypeSchema,
-  data: z26.unknown(),
-  id: z26.string().optional()
+  data: z25.unknown(),
+  id: z25.string().optional()
   // For Last-Event-ID reconnection
 });
-var publicRunEventsContract = c22.router({
+var publicRunEventsContract = c21.router({
   streamEvents: {
     method: "GET",
     path: "/v1/runs/:id/events",
     headers: authHeadersSchema,
-    pathParams: z26.object({
-      id: z26.string().min(1, "Run ID is required")
+    pathParams: z25.object({
+      id: z25.string().min(1, "Run ID is required")
     }),
-    query: z26.object({
-      lastEventId: z26.string().optional()
+    query: z25.object({
+      lastEventId: z25.string().optional()
       // For reconnection
     }),
     responses: {
-      200: z26.any(),
+      200: z25.any(),
       // SSE stream - actual content is text/event-stream
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -4000,28 +4021,28 @@ var publicRunEventsContract = c22.router({
 });
 
 // ../../packages/core/src/contracts/public/artifacts.ts
-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(),
+import { z as z26 } from "zod";
+var c22 = initContract();
+var publicArtifactSchema = z26.object({
+  id: z26.string(),
+  name: z26.string(),
+  currentVersionId: z26.string().nullable(),
+  size: z26.number(),
   // Total size in bytes
-  fileCount: z27.number(),
+  fileCount: z26.number(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema
 });
-var artifactVersionSchema = z27.object({
-  id: z27.string(),
+var artifactVersionSchema = z26.object({
+  id: z26.string(),
   // SHA-256 content hash
-  artifactId: z27.string(),
-  size: z27.number(),
+  artifactId: z26.string(),
+  size: z26.number(),
   // Size in bytes
-  fileCount: z27.number(),
-  message: z27.string().nullable(),
+  fileCount: z26.number(),
+  message: z26.string().nullable(),
   // Optional commit message
-  createdBy: z27.string(),
+  createdBy: z26.string(),
   createdAt: timestampSchema
 });
 var publicArtifactDetailSchema = publicArtifactSchema.extend({
@@ -4031,7 +4052,7 @@ var paginatedArtifactsSchema = createPaginatedResponseSchema(publicArtifactSchem
 var paginatedArtifactVersionsSchema = createPaginatedResponseSchema(
   artifactVersionSchema
 );
-var publicArtifactsListContract = c23.router({
+var publicArtifactsListContract = c22.router({
   list: {
     method: "GET",
     path: "/v1/artifacts",
@@ -4046,13 +4067,13 @@ var publicArtifactsListContract = c23.router({
     description: "List all artifacts in the current scope with pagination"
   }
 });
-var publicArtifactByIdContract = c23.router({
+var publicArtifactByIdContract = c22.router({
   get: {
     method: "GET",
     path: "/v1/artifacts/:id",
     headers: authHeadersSchema,
-    pathParams: z27.object({
-      id: z27.string().min(1, "Artifact ID is required")
+    pathParams: z26.object({
+      id: z26.string().min(1, "Artifact ID is required")
     }),
     responses: {
       200: publicArtifactDetailSchema,
@@ -4064,13 +4085,13 @@ var publicArtifactByIdContract = c23.router({
     description: "Get artifact details by ID"
   }
 });
-var publicArtifactVersionsContract = c23.router({
+var publicArtifactVersionsContract = c22.router({
   list: {
     method: "GET",
     path: "/v1/artifacts/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z27.object({
-      id: z27.string().min(1, "Artifact ID is required")
+    pathParams: z26.object({
+      id: z26.string().min(1, "Artifact ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -4083,20 +4104,20 @@ var publicArtifactVersionsContract = c23.router({
     description: "List all versions of an artifact with pagination"
   }
 });
-var publicArtifactDownloadContract = c23.router({
+var publicArtifactDownloadContract = c22.router({
   download: {
     method: "GET",
     path: "/v1/artifacts/:id/download",
     headers: authHeadersSchema,
-    pathParams: z27.object({
-      id: z27.string().min(1, "Artifact ID is required")
+    pathParams: z26.object({
+      id: z26.string().min(1, "Artifact ID is required")
     }),
-    query: z27.object({
-      versionId: z27.string().optional()
+    query: z26.object({
+      versionId: z26.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z27.undefined(),
+      302: z26.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -4108,28 +4129,28 @@ var publicArtifactDownloadContract = c23.router({
 });
 
 // ../../packages/core/src/contracts/public/volumes.ts
-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(),
+import { z as z27 } from "zod";
+var c23 = initContract();
+var publicVolumeSchema = z27.object({
+  id: z27.string(),
+  name: z27.string(),
+  currentVersionId: z27.string().nullable(),
+  size: z27.number(),
   // Total size in bytes
-  fileCount: z28.number(),
+  fileCount: z27.number(),
   createdAt: timestampSchema,
   updatedAt: timestampSchema
 });
-var volumeVersionSchema = z28.object({
-  id: z28.string(),
+var volumeVersionSchema = z27.object({
+  id: z27.string(),
   // SHA-256 content hash
-  volumeId: z28.string(),
-  size: z28.number(),
+  volumeId: z27.string(),
+  size: z27.number(),
   // Size in bytes
-  fileCount: z28.number(),
-  message: z28.string().nullable(),
+  fileCount: z27.number(),
+  message: z27.string().nullable(),
   // Optional commit message
-  createdBy: z28.string(),
+  createdBy: z27.string(),
   createdAt: timestampSchema
 });
 var publicVolumeDetailSchema = publicVolumeSchema.extend({
@@ -4137,7 +4158,7 @@ var publicVolumeDetailSchema = publicVolumeSchema.extend({
 });
 var paginatedVolumesSchema = createPaginatedResponseSchema(publicVolumeSchema);
 var paginatedVolumeVersionsSchema = createPaginatedResponseSchema(volumeVersionSchema);
-var publicVolumesListContract = c24.router({
+var publicVolumesListContract = c23.router({
   list: {
     method: "GET",
     path: "/v1/volumes",
@@ -4152,13 +4173,13 @@ var publicVolumesListContract = c24.router({
     description: "List all volumes in the current scope with pagination"
   }
 });
-var publicVolumeByIdContract = c24.router({
+var publicVolumeByIdContract = c23.router({
   get: {
     method: "GET",
     path: "/v1/volumes/:id",
     headers: authHeadersSchema,
-    pathParams: z28.object({
-      id: z28.string().min(1, "Volume ID is required")
+    pathParams: z27.object({
+      id: z27.string().min(1, "Volume ID is required")
     }),
     responses: {
       200: publicVolumeDetailSchema,
@@ -4170,13 +4191,13 @@ var publicVolumeByIdContract = c24.router({
     description: "Get volume details by ID"
   }
 });
-var publicVolumeVersionsContract = c24.router({
+var publicVolumeVersionsContract = c23.router({
   list: {
     method: "GET",
     path: "/v1/volumes/:id/versions",
     headers: authHeadersSchema,
-    pathParams: z28.object({
-      id: z28.string().min(1, "Volume ID is required")
+    pathParams: z27.object({
+      id: z27.string().min(1, "Volume ID is required")
     }),
     query: listQuerySchema,
     responses: {
@@ -4189,20 +4210,20 @@ var publicVolumeVersionsContract = c24.router({
     description: "List all versions of a volume with pagination"
   }
 });
-var publicVolumeDownloadContract = c24.router({
+var publicVolumeDownloadContract = c23.router({
   download: {
     method: "GET",
     path: "/v1/volumes/:id/download",
     headers: authHeadersSchema,
-    pathParams: z28.object({
-      id: z28.string().min(1, "Volume ID is required")
+    pathParams: z27.object({
+      id: z27.string().min(1, "Volume ID is required")
     }),
-    query: z28.object({
-      versionId: z28.string().optional()
+    query: z27.object({
+      versionId: z27.string().optional()
       // Defaults to current version
     }),
     responses: {
-      302: z28.undefined(),
+      302: z27.undefined(),
       // Redirect to presigned URL
       401: publicApiErrorSchema,
       404: publicApiErrorSchema,
@@ -4358,64 +4379,6 @@ var FEATURE_SWITCHES = {
   }
 };
 
-// src/lib/api/core/client-factory.ts
-var ApiRequestError = class extends Error {
-  constructor(message, code, status) {
-    super(message);
-    this.code = code;
-    this.status = status;
-    this.name = "ApiRequestError";
-  }
-};
-async function getHeaders() {
-  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;
-}
-async function getBaseUrl() {
-  const apiUrl = await getApiUrl();
-  if (!apiUrl) {
-    throw new Error("API URL not configured");
-  }
-  return apiUrl;
-}
-async function getClientConfig() {
-  const baseUrl = await getBaseUrl();
-  const baseHeaders = await getHeaders();
-  return { baseUrl, baseHeaders, jsonQuery: false };
-}
-function handleError(result, defaultMessage, options) {
-  if (!options?.useServerMessage) {
-    if (result.status === 401) {
-      throw new ApiRequestError(
-        "Not authenticated. Run: vm0 auth login",
-        "UNAUTHORIZED",
-        401
-      );
-    }
-    if (result.status === 403) {
-      throw new ApiRequestError(
-        "An unexpected network issue occurred",
-        "FORBIDDEN",
-        403
-      );
-    }
-  }
-  const errorBody = result.body;
-  const message = errorBody.error?.message || defaultMessage;
-  const code = errorBody.error?.code || "UNKNOWN";
-  throw new ApiRequestError(message, code, result.status);
-}
-
 // src/lib/api/core/http.ts
 async function getRawHeaders() {
   const token = await getToken();
@@ -4601,7 +4564,7 @@ async function getScope() {
   if (result.status === 200) {
     return result.body;
   }
-  handleError(result, "Failed to get scope", { useServerMessage: true });
+  handleError(result, "Failed to get scope");
 }
 async function createScope(body) {
   const config = await getClientConfig();
@@ -4610,7 +4573,7 @@ async function createScope(body) {
   if (result.status === 201) {
     return result.body;
   }
-  handleError(result, "Failed to create scope", { useServerMessage: true });
+  handleError(result, "Failed to create scope");
 }
 async function updateScope(body) {
   const config = await getClientConfig();
@@ -4619,7 +4582,7 @@ async function updateScope(body) {
   if (result.status === 200) {
     return result.body;
   }
-  handleError(result, "Failed to update scope", { useServerMessage: true });
+  handleError(result, "Failed to update scope");
 }
 
 // src/lib/api/domains/storages.ts
@@ -4960,8 +4923,8 @@ async function getUsage(options) {
 }
 
 // src/lib/domain/yaml-validator.ts
-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(
+import { z as z28 } from "zod";
+var cliAgentNameSchema = z28.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"
 );
@@ -4976,7 +4939,7 @@ var cliAgentDefinitionSchema = agentDefinitionSchema.superRefine(
         const skillUrl = agent.skills[i];
         if (skillUrl && !validateGitHubTreeUrl(skillUrl)) {
           ctx.addIssue({
-            code: z29.ZodIssueCode.custom,
+            code: z28.ZodIssueCode.custom,
             message: `Invalid skill URL: ${skillUrl}. Expected format: https://github.com/{owner}/{repo}/tree/{branch}/{path}`,
             path: ["skills", i]
           });
@@ -4985,15 +4948,15 @@ var cliAgentDefinitionSchema = agentDefinitionSchema.superRefine(
     }
   }
 );
-var cliComposeSchema = z29.object({
-  version: z29.string().min(1, "Missing config.version"),
-  agents: z29.record(cliAgentNameSchema, cliAgentDefinitionSchema),
-  volumes: z29.record(z29.string(), volumeConfigSchema).optional()
+var cliComposeSchema = z28.object({
+  version: z28.string().min(1, "Missing config.version"),
+  agents: z28.record(cliAgentNameSchema, cliAgentDefinitionSchema),
+  volumes: z28.record(z28.string(), volumeConfigSchema).optional()
 }).superRefine((config, ctx) => {
   const agentKeys = Object.keys(config.agents);
   if (agentKeys.length === 0) {
     ctx.addIssue({
-      code: z29.ZodIssueCode.custom,
+      code: z28.ZodIssueCode.custom,
       message: "agents must have at least one agent defined",
       path: ["agents"]
     });
@@ -5001,7 +4964,7 @@ var cliComposeSchema = z29.object({
   }
   if (agentKeys.length > 1) {
     ctx.addIssue({
-      code: z29.ZodIssueCode.custom,
+      code: z28.ZodIssueCode.custom,
       message: "Multiple agents not supported yet. Only one agent allowed.",
       path: ["agents"]
     });
@@ -5013,7 +4976,7 @@ var cliComposeSchema = z29.object({
   if (agentVolumes && agentVolumes.length > 0) {
     if (!config.volumes) {
       ctx.addIssue({
-        code: z29.ZodIssueCode.custom,
+        code: z28.ZodIssueCode.custom,
         message: "Agent references volumes but no volumes section defined. Each volume must have explicit name and version.",
         path: ["volumes"]
       });
@@ -5023,7 +4986,7 @@ var cliComposeSchema = z29.object({
       const parts = volDeclaration.split(":");
       if (parts.length !== 2) {
         ctx.addIssue({
-          code: z29.ZodIssueCode.custom,
+          code: z28.ZodIssueCode.custom,
           message: `Invalid volume declaration: ${volDeclaration}. Expected format: volume-key:/mount/path`,
           path: ["agents", agentName, "volumes"]
         });
@@ -5032,7 +4995,7 @@ var cliComposeSchema = z29.object({
       const volumeKey = parts[0].trim();
       if (!config.volumes[volumeKey]) {
         ctx.addIssue({
-          code: z29.ZodIssueCode.custom,
+          code: z28.ZodIssueCode.custom,
           message: `Volume "${volumeKey}" is not defined in volumes section. Each volume must have explicit name and version.`,
           path: ["volumes", volumeKey]
         });
@@ -6136,7 +6099,7 @@ var composeCommand = new Command7().name("compose").description("Create or updat
   `Path to agent YAML file or GitHub tree URL (default: ${DEFAULT_CONFIG_FILE})`
 ).option("-y, --yes", "Skip confirmation prompts for skill requirements").option(
   "--experimental-shared-compose",
-  "Enable GitHub URL compose (experimental)"
+  "[deprecated] No longer required, kept for backward compatibility"
 ).option("--json", "Output JSON for scripts (suppresses interactive output)").option(
   "--porcelain",
   "[deprecated: use --json] Output JSON for scripts",
@@ -6155,36 +6118,11 @@ var composeCommand = new Command7().name("compose").description("Create or updat
       options.autoUpdate = false;
     }
     if (options.autoUpdate !== false) {
-      await startSilentUpgrade("9.29.5");
+      await startSilentUpgrade("9.30.1");
     }
     try {
       let result;
       if (isGitHubUrl(resolvedConfigFile)) {
-        if (!options.experimentalSharedCompose) {
-          if (options.json) {
-            console.log(
-              JSON.stringify({
-                error: "Composing shared agents requires --experimental-shared-compose flag"
-              })
-            );
-          } else {
-            console.error(
-              chalk8.red(
-                "\u2717 Composing shared agents requires --experimental-shared-compose flag"
-              )
-            );
-            console.error();
-            console.error(
-              chalk8.dim(
-                "  Composing agents from other users carries security risks."
-              )
-            );
-            console.error(
-              chalk8.dim("  Only compose agents from users you trust.")
-            );
-          }
-          process.exit(1);
-        }
         result = await handleGitHubCompose(resolvedConfigFile, options);
       } else {
         const { config, agentName, agent, basePath } = await loadAndValidateConfig(resolvedConfigFile, options.json);
@@ -6966,9 +6904,9 @@ var CodexEventParser = class {
       }
     }
     if (itemType === "file_change" && item.changes && item.changes.length > 0) {
-      const changes = item.changes.map((c25) => {
-        const action = c25.kind === "add" ? "Created" : c25.kind === "modify" ? "Modified" : "Deleted";
-        return `${action}: ${c25.path}`;
+      const changes = item.changes.map((c24) => {
+        const action = c24.kind === "add" ? "Created" : c24.kind === "modify" ? "Modified" : "Deleted";
+        return `${action}: ${c24.path}`;
       }).join("\n");
       return {
         type: "text",
@@ -7122,9 +7060,9 @@ var CodexEventRenderer = class {
       return;
     }
     if (itemType === "file_change" && item.changes && item.changes.length > 0) {
-      const summary = item.changes.map((c25) => {
-        const icon = c25.kind === "add" ? "+" : c25.kind === "delete" ? "-" : "~";
-        return `${icon}${c25.path}`;
+      const summary = item.changes.map((c24) => {
+        const icon = c24.kind === "add" ? "+" : c24.kind === "delete" ? "-" : "~";
+        return `${icon}${c24.path}`;
       }).join(", ");
       console.log(chalk11.green("[files]") + ` ${summary}`);
       return;
@@ -8377,7 +8315,7 @@ var mainRunCommand = new Command8().name("run").description("Run an agent").argu
   async (identifier, prompt, options) => {
     try {
       if (options.autoUpdate !== false) {
-        await startSilentUpgrade("9.29.5");
+        await startSilentUpgrade("9.30.1");
       }
       const { scope, name, version } = parseIdentifier(identifier);
       if (scope && !options.experimentalSharedAgent) {
@@ -8785,8 +8723,8 @@ function displayEmptyState(hasFilters) {
 var listCommand = new Command11().name("list").alias("ls").description("List runs").option(
   "--status <status,...>",
   `Filter by status: ${VALID_STATUSES} (default: pending,running)`
-).option("--all", "Show all statuses (mutually exclusive with --status)").option("--agent <name>", "Filter by agent name").option("--since <date>", "Start time (ISO format or relative: 1h, 7d, 30d)").option("--until <date>", "End time (defaults to now)").option("--limit <n>", "Maximum number of results (default: 50, max: 100)").action(async (options) => {
-  try {
+).option("--all", "Show all statuses (mutually exclusive with --status)").option("--agent <name>", "Filter by agent name").option("--since <date>", "Start time (ISO format or relative: 1h, 7d, 30d)").option("--until <date>", "End time (defaults to now)").option("--limit <n>", "Maximum number of results (default: 50, max: 100)").action(
+  withErrorHandler(async (options) => {
     if (options.all && options.status) {
       console.error(
         chalk16.red("Error: --all and --status are mutually exclusive")
@@ -8815,18 +8753,8 @@ var listCommand = new Command11().name("list").alias("ls").description("List run
       return;
     }
     displayRuns(runs);
-  } catch (error) {
-    console.error(chalk16.red("\u2717 Failed to list runs"));
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk16.dim("  Run: vm0 auth login"));
-      } else {
-        console.error(chalk16.dim(`  ${error.message}`));
-      }
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/run/kill.ts
 import { Command as Command12 } from "commander";
@@ -8915,8 +8843,8 @@ async function writeStorageConfig(storageName, basePath = process.cwd(), type2 =
 }
 
 // src/commands/volume/init.ts
-var initCommand = new Command13().name("init").description("Initialize a volume in the current directory").option("-n, --name <name>", "Volume name (required in non-interactive mode)").action(async (options) => {
-  try {
+var initCommand = new Command13().name("init").description("Initialize a volume in the current directory").option("-n, --name <name>", "Volume name (required in non-interactive mode)").action(
+  withErrorHandler(async (options) => {
     const cwd = process.cwd();
     const dirName = path6.basename(cwd);
     const existingConfig = await readStorageConfig(cwd);
@@ -8977,14 +8905,8 @@ var initCommand = new Command13().name("init").description("Initialize a volume
         `  Config saved to ${path6.join(cwd, ".vm0", "storage.yaml")}`
       )
     );
-  } catch (error) {
-    console.error(chalk18.red("\u2717 Failed to initialize volume"));
-    if (error instanceof Error) {
-      console.error(chalk18.dim(`  ${error.message}`));
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/volume/push.ts
 import { Command as Command14 } from "commander";
@@ -8992,8 +8914,8 @@ import chalk19 from "chalk";
 var pushCommand = new Command14().name("push").description("Push local files to cloud volume").option(
   "-f, --force",
   "Force upload even if content unchanged (recreate archive)"
-).action(async (options) => {
-  try {
+).action(
+  withErrorHandler(async (options) => {
     const cwd = process.cwd();
     const config = await readStorageConfig(cwd);
     if (!config) {
@@ -9019,18 +8941,8 @@ var pushCommand = new Command14().name("push").description("Push local files to
     console.log(chalk19.dim(`  Version: ${shortVersion}`));
     console.log(chalk19.dim(`  Files: ${result.fileCount.toLocaleString()}`));
     console.log(chalk19.dim(`  Size: ${formatBytes(result.size)}`));
-  } catch (error) {
-    console.error(chalk19.red("\u2717 Push failed"));
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk19.dim("  Run: vm0 auth login"));
-      } else {
-        console.error(chalk19.dim(`  ${error.message}`));
-      }
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/volume/pull.ts
 import { Command as Command15 } from "commander";
@@ -9053,8 +8965,8 @@ async function handleEmptyStorageResponse(cwd) {
 }
 
 // src/commands/volume/pull.ts
-var pullCommand = new Command15().name("pull").description("Pull cloud files to local directory").argument("[versionId]", "Version ID to pull (default: latest)").action(async (versionId) => {
-  try {
+var pullCommand = new Command15().name("pull").description("Pull cloud files to local directory").argument("[versionId]", "Version ID to pull (default: latest)").action(
+  withErrorHandler(async (versionId) => {
     const cwd = process.cwd();
     const config = await readStorageConfig(cwd);
     if (!config) {
@@ -9112,18 +9024,8 @@ var pullCommand = new Command15().name("pull").description("Pull cloud files to
     await fs6.promises.unlink(tarPath);
     await fs6.promises.rmdir(tmpDir);
     console.log(chalk21.green(`\u2713 Extracted ${remoteFiles.length} files`));
-  } catch (error) {
-    console.error(chalk21.red("\u2717 Pull failed"));
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk21.dim("  Run: vm0 auth login"));
-      } else {
-        console.error(chalk21.dim(`  ${error.message}`));
-      }
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/volume/status.ts
 import { Command as Command16 } from "commander";
@@ -9182,8 +9084,8 @@ var statusCommand2 = new Command16().name("status").description("Show status of
 // src/commands/volume/list.ts
 import { Command as Command17 } from "commander";
 import chalk23 from "chalk";
-var listCommand2 = new Command17().name("list").alias("ls").description("List all remote volumes").action(async () => {
-  try {
+var listCommand2 = new Command17().name("list").alias("ls").description("List all remote volumes").action(
+  withErrorHandler(async () => {
     const items = await listStorages({ type: "volume" });
     if (items.length === 0) {
       console.log(chalk23.dim("No volumes found"));
@@ -9217,18 +9119,8 @@ var listCommand2 = new Command17().name("list").alias("ls").description("List al
       ].join("  ");
       console.log(row);
     }
-  } catch (error) {
-    console.error(chalk23.red("\u2717 Failed to list volumes"));
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk23.dim("  Run: vm0 auth login"));
-      } else {
-        console.error(chalk23.dim(`  ${error.message}`));
-      }
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/volume/clone.ts
 import { Command as Command18 } from "commander";
@@ -9302,8 +9194,8 @@ async function cloneStorage(name, type2, destination, options = {}) {
 }
 
 // src/commands/volume/clone.ts
-var cloneCommand = new Command18().name("clone").description("Clone a remote volume to local directory (latest version)").argument("<name>", "Volume name to clone").argument("[destination]", "Destination directory (default: volume name)").action(async (name, destination) => {
-  try {
+var cloneCommand = new Command18().name("clone").description("Clone a remote volume to local directory (latest version)").argument("<name>", "Volume name to clone").argument("[destination]", "Destination directory (default: volume name)").action(
+  withErrorHandler(async (name, destination) => {
     const targetDir = destination || name;
     console.log(`Cloning volume: ${name}`);
     const result = await cloneStorage(name, "volume", targetDir);
@@ -9311,18 +9203,8 @@ var cloneCommand = new Command18().name("clone").description("Clone a remote vol
 \u2713 Successfully cloned volume: ${name}`));
     console.log(chalk25.dim(`  Location: ${targetDir}/`));
     console.log(chalk25.dim(`  Version: ${result.versionId.slice(0, 8)}`));
-  } catch (error) {
-    console.error(chalk25.red("\u2717 Clone failed"));
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk25.dim("  Run: vm0 auth login"));
-      } else {
-        console.error(chalk25.dim(`  ${error.message}`));
-      }
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/volume/index.ts
 var volumeCommand = new Command19().name("volume").description("Manage volumes (defined in compose, not versioned after run)").addCommand(initCommand).addCommand(pushCommand).addCommand(pullCommand).addCommand(statusCommand2).addCommand(listCommand2).addCommand(cloneCommand);
@@ -9337,8 +9219,8 @@ import path9 from "path";
 var initCommand2 = new Command20().name("init").description("Initialize an artifact in the current directory").option(
   "-n, --name <name>",
   "Artifact name (required in non-interactive mode)"
-).action(async (options) => {
-  try {
+).action(
+  withErrorHandler(async (options) => {
     const cwd = process.cwd();
     const dirName = path9.basename(cwd);
     const existingConfig = await readStorageConfig(cwd);
@@ -9414,14 +9296,8 @@ var initCommand2 = new Command20().name("init").description("Initialize an artif
         `  Config saved to ${path9.join(cwd, ".vm0", "storage.yaml")}`
       )
     );
-  } catch (error) {
-    console.error(chalk26.red("\u2717 Failed to initialize artifact"));
-    if (error instanceof Error) {
-      console.error(chalk26.dim(`  ${error.message}`));
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/artifact/push.ts
 import { Command as Command21 } from "commander";
@@ -9429,8 +9305,8 @@ import chalk27 from "chalk";
 var pushCommand2 = new Command21().name("push").description("Push local files to cloud artifact").option(
   "-f, --force",
   "Force upload even if content unchanged (recreate archive)"
-).action(async (options) => {
-  try {
+).action(
+  withErrorHandler(async (options) => {
     const cwd = process.cwd();
     const config = await readStorageConfig(cwd);
     if (!config) {
@@ -9465,14 +9341,8 @@ var pushCommand2 = new Command21().name("push").description("Push local files to
     console.log(chalk27.dim(`  Version: ${shortVersion}`));
     console.log(chalk27.dim(`  Files: ${result.fileCount.toLocaleString()}`));
     console.log(chalk27.dim(`  Size: ${formatBytes(result.size)}`));
-  } catch (error) {
-    console.error(chalk27.red("\u2717 Push failed"));
-    if (error instanceof Error) {
-      console.error(chalk27.dim(`  ${error.message}`));
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/artifact/pull.ts
 import { Command as Command22 } from "commander";
@@ -9481,8 +9351,8 @@ import path10 from "path";
 import * as fs8 from "fs";
 import * as os7 from "os";
 import * as tar5 from "tar";
-var pullCommand2 = new Command22().name("pull").description("Pull cloud artifact to local directory").argument("[versionId]", "Version ID to pull (default: latest)").action(async (versionId) => {
-  try {
+var pullCommand2 = new Command22().name("pull").description("Pull cloud artifact to local directory").argument("[versionId]", "Version ID to pull (default: latest)").action(
+  withErrorHandler(async (versionId) => {
     const cwd = process.cwd();
     const config = await readStorageConfig(cwd);
     if (!config) {
@@ -9549,14 +9419,8 @@ var pullCommand2 = new Command22().name("pull").description("Pull cloud artifact
     await fs8.promises.unlink(tarPath);
     await fs8.promises.rmdir(tmpDir);
     console.log(chalk28.green(`\u2713 Extracted ${remoteFiles.length} files`));
-  } catch (error) {
-    console.error(chalk28.red("\u2717 Pull failed"));
-    if (error instanceof Error) {
-      console.error(chalk28.dim(`  ${error.message}`));
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/artifact/status.ts
 import { Command as Command23 } from "commander";
@@ -9611,8 +9475,8 @@ var statusCommand3 = new Command23().name("status").description("Show status of
 // src/commands/artifact/list.ts
 import { Command as Command24 } from "commander";
 import chalk30 from "chalk";
-var listCommand3 = new Command24().name("list").alias("ls").description("List all remote artifacts").action(async () => {
-  try {
+var listCommand3 = new Command24().name("list").alias("ls").description("List all remote artifacts").action(
+  withErrorHandler(async () => {
     const items = await listStorages({ type: "artifact" });
     if (items.length === 0) {
       console.log(chalk30.dim("No artifacts found"));
@@ -9648,24 +9512,14 @@ var listCommand3 = new Command24().name("list").alias("ls").description("List al
       ].join("  ");
       console.log(row);
     }
-  } catch (error) {
-    console.error(chalk30.red("\u2717 Failed to list artifacts"));
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk30.dim("  Run: vm0 auth login"));
-      } else {
-        console.error(chalk30.dim(`  ${error.message}`));
-      }
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/artifact/clone.ts
 import { Command as Command25 } from "commander";
 import chalk31 from "chalk";
-var cloneCommand2 = new Command25().name("clone").description("Clone a remote artifact to local directory (latest version)").argument("<name>", "Artifact name to clone").argument("[destination]", "Destination directory (default: artifact name)").action(async (name, destination) => {
-  try {
+var cloneCommand2 = new Command25().name("clone").description("Clone a remote artifact to local directory (latest version)").argument("<name>", "Artifact name to clone").argument("[destination]", "Destination directory (default: artifact name)").action(
+  withErrorHandler(async (name, destination) => {
     const targetDir = destination || name;
     console.log(`Cloning artifact: ${name}`);
     const result = await cloneStorage(name, "artifact", targetDir);
@@ -9673,18 +9527,8 @@ var cloneCommand2 = new Command25().name("clone").description("Clone a remote ar
 \u2713 Successfully cloned artifact: ${name}`));
     console.log(chalk31.dim(`  Location: ${targetDir}/`));
     console.log(chalk31.dim(`  Version: ${result.versionId.slice(0, 8)}`));
-  } catch (error) {
-    console.error(chalk31.red("\u2717 Clone failed"));
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk31.dim("  Run: vm0 auth login"));
-      } else {
-        console.error(chalk31.dim(`  ${error.message}`));
-      }
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/artifact/index.ts
 var artifactCommand = new Command26().name("artifact").description("Manage artifacts (specified at run, versioned after run)").addCommand(initCommand2).addCommand(pushCommand2).addCommand(pullCommand2).addCommand(statusCommand3).addCommand(listCommand3).addCommand(cloneCommand2);
@@ -10044,7 +9888,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.29.5", prompt);
+      const shouldExit = await checkAndUpgrade("9.30.1", prompt);
       if (shouldExit) {
         process.exit(0);
       }
@@ -10735,8 +10579,8 @@ var cloneCommand3 = new Command35().name("clone").description("Clone agent compo
 // src/commands/agent/list.ts
 import { Command as Command36 } from "commander";
 import chalk41 from "chalk";
-var listCommand4 = new Command36().name("list").alias("ls").description("List all agent composes").action(async () => {
-  try {
+var listCommand4 = new Command36().name("list").alias("ls").description("List all agent composes").action(
+  withErrorHandler(async () => {
     const response = await httpGet("/api/agent/composes/list");
     if (!response.ok) {
       const error = await response.json();
@@ -10750,7 +10594,7 @@ var listCommand4 = new Command36().name("list").alias("ls").description("List al
       );
       return;
     }
-    const nameWidth = Math.max(4, ...data.composes.map((c25) => c25.name.length));
+    const nameWidth = Math.max(4, ...data.composes.map((c24) => c24.name.length));
     const header = ["NAME".padEnd(nameWidth), "VERSION", "UPDATED"].join(
       "  "
     );
@@ -10764,18 +10608,8 @@ var listCommand4 = new Command36().name("list").alias("ls").description("List al
       ].join("  ");
       console.log(row);
     }
-  } catch (error) {
-    console.error(chalk41.red("\u2717 Failed to list agent composes"));
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk41.dim("  Run: vm0 auth login"));
-      } else {
-        console.error(chalk41.dim(`  ${error.message}`));
-      }
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/agent/status.ts
 import { Command as Command37 } from "commander";
@@ -11033,204 +10867,300 @@ var statusCommand5 = new Command37().name("status").description("Show status of
 // src/commands/agent/public.ts
 import { Command as Command38 } from "commander";
 import chalk43 from "chalk";
-var publicCommand = new Command38().name("experimental-public").description("Make an agent public (accessible to all authenticated users)").argument("<name>", "Agent name").action(async (name) => {
-  try {
-    const compose = await getComposeByName(name);
-    if (!compose) {
-      console.error(chalk43.red(`\u2717 Agent not found: ${name}`));
-      process.exit(1);
-    }
-    const scope = await getScope();
-    const response = await httpPost(
-      `/api/agent/composes/${compose.id}/permissions`,
-      { granteeType: "public" }
-    );
-    if (!response.ok) {
-      const error = await response.json();
-      if (response.status === 409) {
-        console.log(chalk43.yellow(`Agent "${name}" is already public`));
-        return;
+var publicCommand = new Command38().name("public").description("Make an agent public (accessible to all authenticated users)").argument("<name>", "Agent name").option(
+  "--experimental-shared-agent",
+  "Enable experimental agent sharing feature"
+).action(
+  withErrorHandler(
+    async (name, options) => {
+      if (!options.experimentalSharedAgent) {
+        console.error(
+          chalk43.red(
+            "\u2717 This command requires --experimental-shared-agent flag"
+          )
+        );
+        console.error();
+        console.error(
+          chalk43.dim("  Agent sharing is an experimental feature.")
+        );
+        console.error();
+        console.error("Example:");
+        console.error(
+          chalk43.cyan(
+            `  vm0 agent public ${name} --experimental-shared-agent`
+          )
+        );
+        process.exit(1);
       }
-      throw new Error(error.error?.message || "Failed to make agent public");
-    }
-    const fullName = `${scope.slug}/${name}`;
-    console.log(chalk43.green(`\u2713 Agent "${name}" is now public`));
-    console.log();
-    console.log("Others can now run your agent with:");
-    console.log(
-      chalk43.cyan(
-        `  vm0 run ${fullName} --experimental-shared-agent "your prompt"`
-      )
-    );
-  } catch (error) {
-    console.error(chalk43.red("\u2717 Failed to make agent public"));
-    if (error instanceof Error) {
-      console.error(chalk43.dim(`  ${error.message}`));
+      const compose = await getComposeByName(name);
+      if (!compose) {
+        console.error(chalk43.red(`\u2717 Agent not found: ${name}`));
+        process.exit(1);
+      }
+      const scope = await getScope();
+      const response = await httpPost(
+        `/api/agent/composes/${compose.id}/permissions`,
+        { granteeType: "public" }
+      );
+      if (!response.ok) {
+        const error = await response.json();
+        if (response.status === 409) {
+          console.log(chalk43.yellow(`Agent "${name}" is already public`));
+          return;
+        }
+        throw new Error(
+          error.error?.message || "Failed to make agent public"
+        );
+      }
+      const fullName = `${scope.slug}/${name}`;
+      console.log(chalk43.green(`\u2713 Agent "${name}" is now public`));
+      console.log();
+      console.log("Others can now run your agent with:");
+      console.log(
+        chalk43.cyan(
+          `  vm0 run ${fullName} --experimental-shared-agent "your prompt"`
+        )
+      );
     }
-    process.exit(1);
-  }
-});
+  )
+);
 
 // src/commands/agent/private.ts
 import { Command as Command39 } from "commander";
 import chalk44 from "chalk";
-var privateCommand = new Command39().name("experimental-private").description("Make an agent private (remove public access)").argument("<name>", "Agent name").action(async (name) => {
-  try {
-    const compose = await getComposeByName(name);
-    if (!compose) {
-      console.error(chalk44.red(`\u2717 Agent not found: ${name}`));
-      process.exit(1);
-    }
-    const response = await httpDelete(
-      `/api/agent/composes/${compose.id}/permissions?type=public`
-    );
-    if (!response.ok) {
-      const error = await response.json();
-      if (response.status === 404) {
-        console.log(chalk44.yellow(`Agent "${name}" is already private`));
-        return;
+var privateCommand = new Command39().name("private").description("Make an agent private (remove public access)").argument("<name>", "Agent name").option(
+  "--experimental-shared-agent",
+  "Enable experimental agent sharing feature"
+).action(
+  withErrorHandler(
+    async (name, options) => {
+      if (!options.experimentalSharedAgent) {
+        console.error(
+          chalk44.red(
+            "\u2717 This command requires --experimental-shared-agent flag"
+          )
+        );
+        console.error();
+        console.error(
+          chalk44.dim("  Agent sharing is an experimental feature.")
+        );
+        console.error();
+        console.error("Example:");
+        console.error(
+          chalk44.cyan(
+            `  vm0 agent private ${name} --experimental-shared-agent`
+          )
+        );
+        process.exit(1);
       }
-      throw new Error(error.error?.message || "Failed to make agent private");
-    }
-    console.log(chalk44.green(`\u2713 Agent "${name}" is now private`));
-  } catch (error) {
-    console.error(chalk44.red("\u2717 Failed to make agent private"));
-    if (error instanceof Error) {
-      console.error(chalk44.dim(`  ${error.message}`));
+      const compose = await getComposeByName(name);
+      if (!compose) {
+        console.error(chalk44.red(`\u2717 Agent not found: ${name}`));
+        process.exit(1);
+      }
+      const response = await httpDelete(
+        `/api/agent/composes/${compose.id}/permissions?type=public`
+      );
+      if (!response.ok) {
+        const error = await response.json();
+        if (response.status === 404) {
+          console.log(chalk44.yellow(`Agent "${name}" is already private`));
+          return;
+        }
+        throw new Error(
+          error.error?.message || "Failed to make agent private"
+        );
+      }
+      console.log(chalk44.green(`\u2713 Agent "${name}" is now private`));
     }
-    process.exit(1);
-  }
-});
+  )
+);
 
 // src/commands/agent/share.ts
 import { Command as Command40 } from "commander";
 import chalk45 from "chalk";
-var shareCommand = new Command40().name("experimental-share").description("Share an agent with a user by email").argument("<name>", "Agent name").requiredOption("--email <email>", "Email address to share with").action(async (name, options) => {
-  try {
-    const compose = await getComposeByName(name);
-    if (!compose) {
-      console.error(chalk45.red(`\u2717 Agent not found: ${name}`));
-      process.exit(1);
-    }
-    const scope = await getScope();
-    const response = await httpPost(
-      `/api/agent/composes/${compose.id}/permissions`,
-      { granteeType: "email", granteeEmail: options.email }
-    );
-    if (!response.ok) {
-      const error = await response.json();
-      if (response.status === 409) {
-        console.log(
-          chalk45.yellow(
-            `Agent "${name}" is already shared with ${options.email}`
+var shareCommand = new Command40().name("share").description("Share an agent with a user by email").argument("<name>", "Agent name").requiredOption("--email <email>", "Email address to share with").option(
+  "--experimental-shared-agent",
+  "Enable experimental agent sharing feature"
+).action(
+  withErrorHandler(
+    async (name, options) => {
+      if (!options.experimentalSharedAgent) {
+        console.error(
+          chalk45.red(
+            "\u2717 This command requires --experimental-shared-agent flag"
           )
         );
-        return;
+        console.error();
+        console.error(
+          chalk45.dim("  Agent sharing is an experimental feature.")
+        );
+        console.error();
+        console.error("Example:");
+        console.error(
+          chalk45.cyan(
+            `  vm0 agent share ${name} --email ${options.email} --experimental-shared-agent`
+          )
+        );
+        process.exit(1);
       }
-      throw new Error(error.error?.message || "Failed to share agent");
-    }
-    const fullName = `${scope.slug}/${name}`;
-    console.log(
-      chalk45.green(`\u2713 Agent "${name}" shared with ${options.email}`)
-    );
-    console.log();
-    console.log("They can now run your agent with:");
-    console.log(
-      chalk45.cyan(
-        `  vm0 run ${fullName} --experimental-shared-agent "your prompt"`
-      )
-    );
-  } catch (error) {
-    console.error(chalk45.red("\u2717 Failed to share agent"));
-    if (error instanceof Error) {
-      console.error(chalk45.dim(`  ${error.message}`));
+      const compose = await getComposeByName(name);
+      if (!compose) {
+        console.error(chalk45.red(`\u2717 Agent not found: ${name}`));
+        process.exit(1);
+      }
+      const scope = await getScope();
+      const response = await httpPost(
+        `/api/agent/composes/${compose.id}/permissions`,
+        { granteeType: "email", granteeEmail: options.email }
+      );
+      if (!response.ok) {
+        const error = await response.json();
+        if (response.status === 409) {
+          console.log(
+            chalk45.yellow(
+              `Agent "${name}" is already shared with ${options.email}`
+            )
+          );
+          return;
+        }
+        throw new Error(error.error?.message || "Failed to share agent");
+      }
+      const fullName = `${scope.slug}/${name}`;
+      console.log(
+        chalk45.green(`\u2713 Agent "${name}" shared with ${options.email}`)
+      );
+      console.log();
+      console.log("They can now run your agent with:");
+      console.log(
+        chalk45.cyan(
+          `  vm0 run ${fullName} --experimental-shared-agent "your prompt"`
+        )
+      );
     }
-    process.exit(1);
-  }
-});
+  )
+);
 
 // src/commands/agent/unshare.ts
 import { Command as Command41 } from "commander";
 import chalk46 from "chalk";
-var unshareCommand = new Command41().name("experimental-unshare").description("Remove sharing from a user").argument("<name>", "Agent name").requiredOption("--email <email>", "Email address to unshare").action(async (name, options) => {
-  try {
-    const compose = await getComposeByName(name);
-    if (!compose) {
-      console.error(chalk46.red(`\u2717 Agent not found: ${name}`));
-      process.exit(1);
-    }
-    const response = await httpDelete(
-      `/api/agent/composes/${compose.id}/permissions?type=email&email=${encodeURIComponent(options.email)}`
-    );
-    if (!response.ok) {
-      const error = await response.json();
-      if (response.status === 404) {
-        console.log(
-          chalk46.yellow(`Agent "${name}" is not shared with ${options.email}`)
+var unshareCommand = new Command41().name("unshare").description("Remove sharing from a user").argument("<name>", "Agent name").requiredOption("--email <email>", "Email address to unshare").option(
+  "--experimental-shared-agent",
+  "Enable experimental agent sharing feature"
+).action(
+  withErrorHandler(
+    async (name, options) => {
+      if (!options.experimentalSharedAgent) {
+        console.error(
+          chalk46.red(
+            "\u2717 This command requires --experimental-shared-agent flag"
+          )
         );
-        return;
+        console.error();
+        console.error(
+          chalk46.dim("  Agent sharing is an experimental feature.")
+        );
+        console.error();
+        console.error("Example:");
+        console.error(
+          chalk46.cyan(
+            `  vm0 agent unshare ${name} --email ${options.email} --experimental-shared-agent`
+          )
+        );
+        process.exit(1);
       }
-      throw new Error(error.error?.message || "Failed to unshare agent");
-    }
-    console.log(
-      chalk46.green(`\u2713 Removed sharing of "${name}" from ${options.email}`)
-    );
-  } catch (error) {
-    console.error(chalk46.red("\u2717 Failed to unshare agent"));
-    if (error instanceof Error) {
-      console.error(chalk46.dim(`  ${error.message}`));
+      const compose = await getComposeByName(name);
+      if (!compose) {
+        console.error(chalk46.red(`\u2717 Agent not found: ${name}`));
+        process.exit(1);
+      }
+      const response = await httpDelete(
+        `/api/agent/composes/${compose.id}/permissions?type=email&email=${encodeURIComponent(options.email)}`
+      );
+      if (!response.ok) {
+        const error = await response.json();
+        if (response.status === 404) {
+          console.log(
+            chalk46.yellow(
+              `Agent "${name}" is not shared with ${options.email}`
+            )
+          );
+          return;
+        }
+        throw new Error(error.error?.message || "Failed to unshare agent");
+      }
+      console.log(
+        chalk46.green(`\u2713 Removed sharing of "${name}" from ${options.email}`)
+      );
     }
-    process.exit(1);
-  }
-});
+  )
+);
 
 // src/commands/agent/permission.ts
 import { Command as Command42 } from "commander";
 import chalk47 from "chalk";
-var permissionCommand = new Command42().name("experimental-permission").description("List all permissions for an agent").argument("<name>", "Agent name").action(async (name) => {
-  try {
-    const compose = await getComposeByName(name);
-    if (!compose) {
-      console.error(chalk47.red(`\u2717 Agent not found: ${name}`));
-      process.exit(1);
-    }
-    const response = await httpGet(
-      `/api/agent/composes/${compose.id}/permissions`
-    );
-    if (!response.ok) {
-      const error = await response.json();
-      throw new Error(error.error?.message || "Failed to list permissions");
-    }
-    const data = await response.json();
-    if (data.permissions.length === 0) {
-      console.log(chalk47.dim("No permissions set (private agent)"));
-      return;
-    }
-    console.log(
-      chalk47.dim(
-        "TYPE     EMAIL                          PERMISSION  GRANTED"
-      )
-    );
-    console.log(
-      chalk47.dim(
-        "-------  -----------------------------  ----------  ----------"
-      )
-    );
-    for (const p of data.permissions) {
-      const type2 = p.granteeType.padEnd(7);
-      const email = (p.granteeEmail ?? "-").padEnd(29);
-      const permission = p.permission.padEnd(10);
-      const granted = formatRelativeTime(p.createdAt);
-      console.log(`${type2}  ${email}  ${permission}  ${granted}`);
-    }
-  } catch (error) {
-    console.error(chalk47.red("\u2717 Failed to list permissions"));
-    if (error instanceof Error) {
-      console.error(chalk47.dim(`  ${error.message}`));
+var permissionCommand = new Command42().name("permission").description("List all permissions for an agent").argument("<name>", "Agent name").option(
+  "--experimental-shared-agent",
+  "Enable experimental agent sharing feature"
+).action(
+  withErrorHandler(
+    async (name, options) => {
+      if (!options.experimentalSharedAgent) {
+        console.error(
+          chalk47.red(
+            "\u2717 This command requires --experimental-shared-agent flag"
+          )
+        );
+        console.error();
+        console.error(
+          chalk47.dim("  Agent sharing is an experimental feature.")
+        );
+        console.error();
+        console.error("Example:");
+        console.error(
+          chalk47.cyan(
+            `  vm0 agent permission ${name} --experimental-shared-agent`
+          )
+        );
+        process.exit(1);
+      }
+      const compose = await getComposeByName(name);
+      if (!compose) {
+        console.error(chalk47.red(`\u2717 Agent not found: ${name}`));
+        process.exit(1);
+      }
+      const response = await httpGet(
+        `/api/agent/composes/${compose.id}/permissions`
+      );
+      if (!response.ok) {
+        const error = await response.json();
+        throw new Error(error.error?.message || "Failed to list permissions");
+      }
+      const data = await response.json();
+      if (data.permissions.length === 0) {
+        console.log(chalk47.dim("No permissions set (private agent)"));
+        return;
+      }
+      console.log(
+        chalk47.dim(
+          "TYPE     EMAIL                          PERMISSION  GRANTED"
+        )
+      );
+      console.log(
+        chalk47.dim(
+          "-------  -----------------------------  ----------  ----------"
+        )
+      );
+      for (const p of data.permissions) {
+        const type2 = p.granteeType.padEnd(7);
+        const email = (p.granteeEmail ?? "-").padEnd(29);
+        const permission = p.permission.padEnd(10);
+        const granted = formatRelativeTime(p.createdAt);
+        console.log(`${type2}  ${email}  ${permission}  ${granted}`);
+      }
     }
-    process.exit(1);
-  }
-});
+  )
+);
 
 // src/commands/agent/index.ts
 var agentCommand = new Command43().name("agent").description("Manage agent composes").addCommand(cloneCommand3).addCommand(listCommand4).addCommand(statusCommand5).addCommand(publicCommand).addCommand(privateCommand).addCommand(shareCommand).addCommand(unshareCommand).addCommand(permissionCommand);
@@ -11574,7 +11504,7 @@ async function gatherFrequency(optionFrequency, existingFrequency) {
     );
     process.exit(1);
   }
-  const defaultIndex = existingFrequency ? FREQUENCY_CHOICES.findIndex((c25) => c25.value === existingFrequency) : 0;
+  const defaultIndex = existingFrequency ? FREQUENCY_CHOICES.findIndex((c24) => c24.value === existingFrequency) : 0;
   frequency = await promptSelect(
     "Schedule frequency",
     FREQUENCY_CHOICES,
@@ -11603,7 +11533,7 @@ async function gatherDay(frequency, optionDay, existingDay) {
     process.exit(1);
   }
   if (frequency === "weekly") {
-    const defaultDayIndex = existingDay !== void 0 ? DAY_OF_WEEK_CHOICES.findIndex((c25) => c25.value === existingDay) : 0;
+    const defaultDayIndex = existingDay !== void 0 ? DAY_OF_WEEK_CHOICES.findIndex((c24) => c24.value === existingDay) : 0;
     const day2 = await promptSelect(
       "Day of week",
       DAY_OF_WEEK_CHOICES,
@@ -11764,17 +11694,6 @@ Deploying schedule for agent ${chalk49.cyan(params.agentName)}...`
   });
   return deployResult;
 }
-function handleSetupError(error) {
-  console.error(chalk49.red("\u2717 Failed to setup schedule"));
-  if (error instanceof Error) {
-    if (error.message.includes("Not authenticated")) {
-      console.error(chalk49.dim("  Run: vm0 auth login"));
-    } else {
-      console.error(chalk49.dim(`  ${error.message}`));
-    }
-  }
-  process.exit(1);
-}
 function displayDeployResult(agentName, deployResult) {
   if (deployResult.created) {
     console.log(
@@ -11848,8 +11767,8 @@ async function handleScheduleEnabling(params) {
     showEnableHint(agentName);
   }
 }
-var setupCommand = new Command45().name("setup").description("Create or edit a schedule for an agent").argument("<agent-name>", "Agent name to configure schedule for").option("-f, --frequency <type>", "Frequency: daily|weekly|monthly|once").option("-t, --time <HH:MM>", "Time to run (24-hour format)").option("-d, --day <day>", "Day of week (mon-sun) or day of month (1-31)").option("-z, --timezone <tz>", "IANA timezone").option("-p, --prompt <text>", "Prompt to run").option("--artifact-name <name>", "Artifact name", "artifact").option("-e, --enable", "Enable schedule immediately after creation").action(async (agentName, options) => {
-  try {
+var setupCommand = new Command45().name("setup").description("Create or edit a schedule for an agent").argument("<agent-name>", "Agent name to configure schedule for").option("-f, --frequency <type>", "Frequency: daily|weekly|monthly|once").option("-t, --time <HH:MM>", "Time to run (24-hour format)").option("-d, --day <day>", "Day of week (mon-sun) or day of month (1-31)").option("-z, --timezone <tz>", "IANA timezone").option("-p, --prompt <text>", "Prompt to run").option("--artifact-name <name>", "Artifact name", "artifact").option("-e, --enable", "Enable schedule immediately after creation").action(
+  withErrorHandler(async (agentName, options) => {
     const { composeId, scheduleName } = await resolveAgent(agentName);
     const existingSchedule = await findExistingSchedule(agentName);
     console.log(
@@ -11909,16 +11828,14 @@ var setupCommand = new Command45().name("setup").description("Create or edit a s
       enableFlag: options.enable ?? false,
       shouldPromptEnable
     });
-  } catch (error) {
-    handleSetupError(error);
-  }
-});
+  })
+);
 
 // src/commands/schedule/list.ts
 import { Command as Command46 } from "commander";
 import chalk50 from "chalk";
-var listCommand5 = new Command46().name("list").alias("ls").description("List all schedules").action(async () => {
-  try {
+var listCommand5 = new Command46().name("list").alias("ls").description("List all schedules").action(
+  withErrorHandler(async () => {
     const result = await listSchedules();
     if (result.schedules.length === 0) {
       console.log(chalk50.dim("No schedules found"));
@@ -11957,18 +11874,8 @@ var listCommand5 = new Command46().name("list").alias("ls").description("List al
       ].join("  ");
       console.log(row);
     }
-  } catch (error) {
-    console.error(chalk50.red("\u2717 Failed to list schedules"));
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk50.dim("  Run: vm0 auth login"));
-      } else {
-        console.error(chalk50.dim(`  ${error.message}`));
-      }
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/schedule/status.ts
 import { Command as Command47 } from "commander";
@@ -12403,8 +12310,8 @@ import { Command as Command56 } from "commander";
 // src/commands/secret/list.ts
 import { Command as Command53 } from "commander";
 import chalk56 from "chalk";
-var listCommand6 = new Command53().name("list").alias("ls").description("List all secrets").action(async () => {
-  try {
+var listCommand6 = new Command53().name("list").alias("ls").description("List all secrets").action(
+  withErrorHandler(async () => {
     const result = await listSecrets();
     if (result.secrets.length === 0) {
       console.log(chalk56.dim("No secrets found"));
@@ -12444,19 +12351,8 @@ var listCommand6 = new Command53().name("list").alias("ls").description("List al
       console.log();
     }
     console.log(chalk56.dim(`Total: ${result.secrets.length} secret(s)`));
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk56.red("\u2717 Not authenticated. Run: vm0 auth login"));
-      } else {
-        console.error(chalk56.red(`\u2717 ${error.message}`));
-      }
-    } else {
-      console.error(chalk56.red("\u2717 An unexpected error occurred"));
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/secret/set.ts
 import { Command as Command54 } from "commander";
@@ -12579,8 +12475,8 @@ function truncateValue(value, maxLength = 60) {
   }
   return value.slice(0, maxLength - 15) + "... [truncated]";
 }
-var listCommand7 = new Command57().name("list").alias("ls").description("List all variables").action(async () => {
-  try {
+var listCommand7 = new Command57().name("list").alias("ls").description("List all variables").action(
+  withErrorHandler(async () => {
     const result = await listVariables();
     if (result.variables.length === 0) {
       console.log(chalk59.dim("No variables found"));
@@ -12603,19 +12499,8 @@ var listCommand7 = new Command57().name("list").alias("ls").description("List al
       console.log();
     }
     console.log(chalk59.dim(`Total: ${result.variables.length} variable(s)`));
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk59.red("\u2717 Not authenticated. Run: vm0 auth login"));
-      } else {
-        console.error(chalk59.red(`\u2717 ${error.message}`));
-      }
-    } else {
-      console.error(chalk59.red("\u2717 An unexpected error occurred"));
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/variable/set.ts
 import { Command as Command58 } from "commander";
@@ -12712,8 +12597,8 @@ import { Command as Command65 } from "commander";
 // src/commands/model-provider/list.ts
 import { Command as Command61 } from "commander";
 import chalk62 from "chalk";
-var listCommand8 = new Command61().name("list").alias("ls").description("List all model providers").action(async () => {
-  try {
+var listCommand8 = new Command61().name("list").alias("ls").description("List all model providers").action(
+  withErrorHandler(async () => {
     const result = await listModelProviders();
     if (result.modelProviders.length === 0) {
       console.log(chalk62.dim("No model providers configured"));
@@ -12752,19 +12637,8 @@ var listCommand8 = new Command61().name("list").alias("ls").description("List al
     console.log(
       chalk62.dim(`Total: ${result.modelProviders.length} provider(s)`)
     );
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk62.red("\u2717 Not authenticated. Run: vm0 auth login"));
-      } else {
-        console.error(chalk62.red(`\u2717 ${error.message}`));
-      }
-    } else {
-      console.error(chalk62.red("\u2717 An unexpected error occurred"));
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/model-provider/setup.ts
 import { Command as Command62 } from "commander";
@@ -13177,19 +13051,6 @@ async function handleInteractiveMode() {
   const selectedModel = await promptForModelSelection(type2);
   return { type: type2, secret, selectedModel, isInteractiveMode: true };
 }
-function handleSetupError2(error) {
-  if (error instanceof Error) {
-    if (error.message.includes("Not authenticated")) {
-      console.error(chalk63.red("\u2717 Not authenticated"));
-      console.error(chalk63.dim("  Run: vm0 auth login"));
-    } else {
-      console.error(chalk63.red(`\u2717 ${error.message}`));
-    }
-  } else {
-    console.error(chalk63.red("\u2717 An unexpected error occurred"));
-  }
-  process.exit(1);
-}
 async function promptSetAsDefault(type2, framework, isDefault) {
   if (isDefault) return;
   const response = await prompts2(
@@ -13218,8 +13079,8 @@ var setupCommand2 = new Command62().name("setup").description("Configure a model
   "-a, --auth-method <method>",
   "Auth method (required for multi-auth providers like aws-bedrock)"
 ).option("-m, --model <model>", "Model selection (for non-interactive mode)").action(
-  async (options) => {
-    try {
+  withErrorHandler(
+    async (options) => {
       let input;
       const secretArgs = options.secret ?? [];
       if (options.type && secretArgs.length > 0) {
@@ -13288,10 +13149,8 @@ var setupCommand2 = new Command62().name("setup").description("Configure a model
           provider.isDefault
         );
       }
-    } catch (error) {
-      handleSetupError2(error);
     }
-  }
+  )
 );
 
 // src/commands/model-provider/delete.ts
@@ -13497,10 +13356,10 @@ ${type2} connected successfully!`));
 // src/commands/connector/list.ts
 import { Command as Command67 } from "commander";
 import chalk67 from "chalk";
-var listCommand9 = new Command67().name("list").alias("ls").description("List all connectors and their status").action(async () => {
-  try {
+var listCommand9 = new Command67().name("list").alias("ls").description("List all connectors and their status").action(
+  withErrorHandler(async () => {
     const result = await listConnectors();
-    const connectedMap = new Map(result.connectors.map((c25) => [c25.type, c25]));
+    const connectedMap = new Map(result.connectors.map((c24) => [c24.type, c24]));
     const allTypes = Object.keys(CONNECTOR_TYPES);
     const typeWidth = Math.max(4, ...allTypes.map((t) => t.length));
     const statusText = "STATUS";
@@ -13521,29 +13380,15 @@ var listCommand9 = new Command67().name("list").alias("ls").description("List al
     console.log();
     console.log(chalk67.dim("To connect a service:"));
     console.log(chalk67.dim("  vm0 connector connect <type>"));
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk67.red("\u2717 Not authenticated. Run: vm0 auth login"));
-      } else {
-        console.error(chalk67.red(`\u2717 ${error.message}`));
-        if (error.cause instanceof Error) {
-          console.error(chalk67.dim(`  Cause: ${error.cause.message}`));
-        }
-      }
-    } else {
-      console.error(chalk67.red("\u2717 An unexpected error occurred"));
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/connector/status.ts
 import { Command as Command68 } from "commander";
 import chalk68 from "chalk";
 var LABEL_WIDTH = 16;
-var statusCommand7 = new Command68().name("status").description("Show detailed status of a connector").argument("<type>", "Connector type (e.g., github)").action(async (type2) => {
-  try {
+var statusCommand7 = new Command68().name("status").description("Show detailed status of a connector").argument("<type>", "Connector type (e.g., github)").action(
+  withErrorHandler(async (type2) => {
     const parseResult = connectorTypeSchema.safeParse(type2);
     if (!parseResult.success) {
       console.error(chalk68.red(`\u2717 Unknown connector type: ${type2}`));
@@ -13591,22 +13436,8 @@ var statusCommand7 = new Command68().name("status").description("Show detailed s
       console.log(chalk68.dim("To connect:"));
       console.log(chalk68.dim(`  vm0 connector connect ${type2}`));
     }
-  } catch (error) {
-    if (error instanceof Error) {
-      if (error.message.includes("Not authenticated")) {
-        console.error(chalk68.red("\u2717 Not authenticated. Run: vm0 auth login"));
-      } else {
-        console.error(chalk68.red(`\u2717 ${error.message}`));
-        if (error.cause instanceof Error) {
-          console.error(chalk68.dim(`  Cause: ${error.cause.message}`));
-        }
-      }
-    } else {
-      console.error(chalk68.red("\u2717 An unexpected error occurred"));
-    }
-    process.exit(1);
-  }
-});
+  })
+);
 
 // src/commands/connector/disconnect.ts
 import { Command as Command69 } from "commander";
@@ -14077,16 +13908,16 @@ async function handleModelProvider(ctx) {
     const providerType = await step.prompt(
       () => promptSelect(
         "Select provider type:",
-        choices.map((c25) => ({
-          title: c25.label,
-          value: c25.type
+        choices.map((c24) => ({
+          title: c24.label,
+          value: c24.type
         }))
       )
     );
     if (!providerType) {
       process.exit(0);
     }
-    const selectedChoice = choices.find((c25) => c25.type === providerType);
+    const selectedChoice = choices.find((c24) => c24.type === providerType);
     if (selectedChoice?.helpText) {
       for (const line of selectedChoice.helpText.split("\n")) {
         step.detail(chalk73.dim(line));
@@ -14263,26 +14094,24 @@ var onboardCommand = new Command71().name("onboard").description("Guided setup f
 // src/commands/setup-claude/index.ts
 import { Command as Command72 } from "commander";
 import chalk74 from "chalk";
-var setupClaudeCommand = new Command72().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(chalk74.dim("Installing VM0 Claude Plugin..."));
-  const scope = options.scope === "user" ? "user" : "project";
-  try {
+var setupClaudeCommand = new Command72().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(
+  withErrorHandler(async (options) => {
+    console.log(chalk74.dim("Installing VM0 Claude Plugin..."));
+    const scope = options.scope === "user" ? "user" : "project";
     const result = await installVm0Plugin(scope, options.agentDir);
     console.log(
       chalk74.green(`\u2713 Installed ${result.pluginId} (scope: ${result.scope})`)
     );
-  } catch (error) {
-    handlePluginError(error);
-  }
-  console.log();
-  console.log("Next step:");
-  const cdPrefix = options.agentDir ? `cd ${options.agentDir} && ` : "";
-  console.log(
-    chalk74.cyan(
-      `  ${cdPrefix}claude "/${PRIMARY_SKILL_NAME} let's build a workflow"`
-    )
-  );
-});
+    console.log();
+    console.log("Next step:");
+    const cdPrefix = options.agentDir ? `cd ${options.agentDir} && ` : "";
+    console.log(
+      chalk74.cyan(
+        `  ${cdPrefix}claude "/${PRIMARY_SKILL_NAME} let's build a workflow"`
+      )
+    );
+  })
+);
 
 // src/commands/dashboard/index.ts
 import { Command as Command73 } from "commander";
@@ -14390,60 +14219,62 @@ var composeCommand2 = new Command74().name("compose").description("Test server-s
   (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...");
+  withErrorHandler(
+    async (githubUrl, options) => {
+      const intervalMs = options.interval * 1e3;
+      const timeoutMs = options.timeout * 1e3;
+      if (options.json) {
+        try {
+          const { jobId: jobId2, status: initialStatus2 } = await createComposeJob(
+            githubUrl,
+            options.overwrite
+          );
+          if (initialStatus2 === "completed" || initialStatus2 === "failed") {
+            const finalJob3 = await getComposeJobStatus(jobId2);
+            console.log(JSON.stringify(finalJob3, null, 2));
+            process.exit(finalJob3.status === "completed" ? 0 : 1);
+          }
+          const finalJob2 = await pollUntilComplete(
+            jobId2,
+            intervalMs,
+            timeoutMs,
+            true
+          );
+          console.log(JSON.stringify(finalJob2, null, 2));
+          process.exit(finalJob2.status === "completed" ? 0 : 1);
+        } catch (error) {
+          console.log(
+            JSON.stringify({
+              error: error instanceof Error ? error.message : String(error)
+            })
+          );
+          process.exit(1);
+        }
+        return;
       }
+      console.log("Creating compose job...");
       const { jobId, status: initialStatus } = await createComposeJob(
         githubUrl,
         options.overwrite
       );
-      if (!options.json) {
-        console.log(`Job ID: ${chalk76.cyan(jobId)}`);
-        console.log();
-      }
+      console.log(`Job ID: ${chalk76.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);
-        }
+        displayResult(finalJob2);
         process.exit(finalJob2.status === "completed" ? 0 : 1);
       }
       const finalJob = await pollUntilComplete(
         jobId,
         intervalMs,
         timeoutMs,
-        !!options.json
+        false
       );
-      if (options.json) {
-        console.log(JSON.stringify(finalJob, null, 2));
-      } else {
-        console.log();
-        displayResult(finalJob);
-      }
+      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(
-          chalk76.red(
-            `\u2717 ${error instanceof Error ? error.message : String(error)}`
-          )
-        );
-      }
-      process.exit(1);
     }
-  }
+  )
 );
 function displayResult(job) {
   if (job.status === "completed" && job.result) {
@@ -14473,7 +14304,7 @@ var devToolCommand = new Command75().name("dev-tool").description("Developer too
 
 // src/index.ts
 var program = new Command76();
-program.name("vm0").description("VM0 CLI - Build and run agents with natural language").version("9.29.5");
+program.name("vm0").description("VM0 CLI - Build and run agents with natural language").version("9.30.1");
 program.addCommand(authCommand);
 program.addCommand(infoCommand);
 program.addCommand(composeCommand);