omnara 1.0.0 → 1.0.2

package/dist/bin.js

@@ -210,7 +210,7 @@ function createSseClient({
   ...options
 }) {
   let lastEventId;
-  const sleep2 = sseSleepFn ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
+  const sleep2 = sseSleepFn ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms)));
   const createStream = async function* () {
     let retryDelay = sseDefaultRetryDelay ?? 3e3;
     let attempt = 0;
@@ -971,6 +971,9 @@ var client = createClient(createConfig({ throwOnError: true }));
 
 // ../sdk/src/generated/zod.gen.ts
 import * as z from "zod";
+var zResourceName = z.string().min(1).refine((value) => Array.from(value).length <= 64, { message: "Resource name cannot exceed 64 Unicode characters" }).transform((value) => value.normalize("NFC")).refine((value) => Array.from(value).length <= 64, { message: "Resource name cannot exceed 64 Unicode characters" }).refine((value) => !new RegExp("^\\p{White_Space}|\\p{White_Space}$", "u").test(value), { message: "Resource name must not start or end with whitespace" }).refine((value) => !/[\p{Cc}\p{Cf}\p{Cs}\p{Default_Ignorable_Code_Point}⠀]/u.test(value), { message: "Resource name contains an unsupported invisible, control, or format character" }).refine((value) => !value.includes("\uFFFD"), { message: "Resource name contains the Unicode replacement character" }).refine((value) => !Array.from(value).some((character) => character !== " " && new RegExp("\\p{White_Space}", "u").test(character)), { message: "Resource name may only use ordinary spaces" });
+var zAgentName = z.string().refine((value) => Array.from(value).length <= 64, { message: "Resource name cannot exceed 64 Unicode characters" }).transform((value) => value.normalize("NFC")).refine((value) => Array.from(value).length <= 64, { message: "Resource name cannot exceed 64 Unicode characters" }).refine((value) => !new RegExp("^\\p{White_Space}|\\p{White_Space}$", "u").test(value), { message: "Resource name must not start or end with whitespace" }).refine((value) => !/[\p{Cc}\p{Cf}\p{Cs}\p{Default_Ignorable_Code_Point}⠀]/u.test(value), { message: "Resource name contains an unsupported invisible, control, or format character" }).refine((value) => !value.includes("\uFFFD"), { message: "Resource name contains the Unicode replacement character" }).refine((value) => !Array.from(value).some((character) => character !== " " && new RegExp("\\p{White_Space}", "u").test(character)), { message: "Resource name may only use ordinary spaces" });
+var zSkillName = z.string().min(1).max(64).regex(/^[a-z0-9]+(?:-[a-z0-9]+)*$/);
 var zResourceListSort = z.enum([
   "name",
   "-name",
@@ -1098,7 +1101,7 @@ var zModelCatalog = z.object({
   error: z.string().optional()
 });
 var zCreateConfiguredModelRequest = z.object({
-  name: z.string().min(1),
+  name: zResourceName,
   provider_model_slug: z.string().min(1),
   context_window_tokens: z.int().gte(2).lte(2147483647),
   max_output_tokens: z.int().gte(1).lte(2147483647).optional(),
@@ -1113,7 +1116,7 @@ var zCreateConfiguredModelRequest = z.object({
   api_variant_options: zModelApiVariantOptions.optional()
 });
 var zUpdateConfiguredModelRequest = z.object({
-  name: z.string().min(1).optional(),
+  name: zResourceName.optional(),
   provider_model_slug: z.string().min(1).optional(),
   context_window_tokens: z.int().gte(2).lte(2147483647).optional(),
   max_output_tokens: z.int().gte(1).lte(2147483647).optional(),
@@ -1162,7 +1165,7 @@ var zSkillRevisionId = z.string().regex(/^skr_[a-z2-7]{26}$/);
 var zSkillGrantId = z.string().regex(/^skg_[a-z2-7]{26}$/);
 var zSecretId = z.string().regex(/^sec_[a-z2-7]{26}$/);
 var zCreateModelProviderConfigRequest = z.object({
-  name: z.string().min(1),
+  name: zResourceName,
   preset: z.enum([
     "openai",
     "openrouter",
@@ -1200,7 +1203,7 @@ var zModelProviderConfig = z.object({
   id: zModelProviderConfigId,
   org_id: zOrganizationId,
   management_kind: zManagementKind,
-  name: z.string(),
+  name: zResourceName,
   api_format: zModelApiFormat,
   api_variant: zModelProviderApiVariantResponse,
   base_url: z.string(),
@@ -1227,7 +1230,7 @@ var zConfiguredModel = z.object({
   org_id: zOrganizationId,
   model_provider_config_id: zModelProviderConfigId,
   management_kind: zManagementKind,
-  name: z.string(),
+  name: zResourceName,
   current_revision_id: zConfiguredModelRevisionId,
   provider_model_slug: z.string(),
   context_window_tokens: z.int(),
@@ -1274,8 +1277,8 @@ var zConfiguredModelSummary = z.object({
   id: zConfiguredModelId,
   org_id: zOrganizationId,
   model_provider_config_id: zModelProviderConfigId,
-  name: z.string(),
-  provider_config: z.string(),
+  name: zResourceName,
+  provider_config: zResourceName,
   created_at: zTimestamp,
   updated_at: zTimestamp
 });
@@ -1326,7 +1329,7 @@ var zSkill = z.object({
   id: zSkillId,
   org_id: zOrganizationId,
   owner: zSkillOwner,
-  name: z.string(),
+  name: zSkillName,
   revision_id: zSkillRevisionId,
   revision: z.int().gte(1).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
   description: z.string(),
@@ -1465,8 +1468,8 @@ var zToolCatalog = z.object({
   mcp_tool_permissions: zToolPermissionProfile
 });
 var zAgentConfigModel = z.object({
-  provider_config: z.string(),
-  name: z.string(),
+  provider_config: zResourceName,
+  name: zResourceName,
   provider_model_slug: z.string(),
   configured_model_id: zConfiguredModelId,
   current_revision_id: zConfiguredModelRevisionId,
@@ -1497,7 +1500,7 @@ var zAgentConfig = z.object({
   created_at: zTimestamp
 });
 var zCreateAgentProfileRequest = z.object({
-  name: z.string(),
+  name: zResourceName,
   config: zAgentConfigId
 });
 var zUpdateAgentProfileRequest = z.object({
@@ -1505,13 +1508,13 @@ var zUpdateAgentProfileRequest = z.object({
   expected_current_config_id: zAgentConfigId
 });
 var zRenameAgentProfileRequest = z.object({
-  name: z.string()
+  name: zResourceName
 });
 var zAgentProfile = z.object({
   id: zAgentProfileId,
   org_id: zOrganizationId,
   project_id: zProjectId,
-  name: z.string(),
+  name: zResourceName,
   current_config_id: zAgentConfigId,
   current_generation: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
   current_config: zAgentConfig,
@@ -1543,7 +1546,7 @@ var zCronTriggerFailureReport = z.object({
   failed_at: zTimestamp
 });
 var zCreateCronTriggerRequest = z.object({
-  name: z.string(),
+  name: zResourceName,
   target: zCronTriggerTarget,
   cron: zCronExpression,
   timezone: zCronTimezone.optional(),
@@ -1551,7 +1554,7 @@ var zCreateCronTriggerRequest = z.object({
   enabled: z.boolean().optional().default(true)
 });
 var zUpdateCronTriggerRequest = z.object({
-  name: z.string().optional(),
+  name: zResourceName.optional(),
   cron: zCronExpression.optional(),
   timezone: zCronTimezone.optional(),
   message_template: zCronMessageTemplate.optional(),
@@ -1561,7 +1564,7 @@ var zCronTrigger = z.object({
   id: zCronTriggerId,
   org_id: zOrganizationId,
   project_id: zProjectId,
-  name: z.string(),
+  name: zResourceName,
   target: zCronTriggerTarget,
   cron: zCronExpression,
   timezone: zCronTimezone,
@@ -1580,12 +1583,12 @@ var zListCronTriggersResponse = z.object({
 var zCreateAgentRequest = z.object({
   profile: zAgentProfileId.optional(),
   config: zAgentConfigId,
-  name: z.string().optional(),
+  name: zAgentName.optional(),
   message: z.string().optional()
 });
 var zAgentModel = z.object({
-  provider_config: z.string(),
-  name: z.string()
+  provider_config: zResourceName,
+  name: zResourceName
 });
 var zIntegrationTarget = z.object({
   provider: z.string(),
@@ -1600,7 +1603,7 @@ var zAgent = z.object({
   project_id: zProjectId,
   agent_profile_id: zAgentProfileId.optional(),
   state: z.enum(["active", "archived"]),
-  name: z.string(),
+  name: zAgentName,
   integration_target: zIntegrationTarget.optional(),
   current_config_id: zAgentConfigId.optional(),
   model: zAgentModel.optional(),
@@ -2174,7 +2177,7 @@ var zSecretOwnerInput = z.discriminatedUnion("kind", [
 var zMcpoAuthStartRequest = z.object({
   owner: zSecretOwnerInput,
   mcp_url: z.string().min(1),
-  name: z.string().min(1),
+  name: zResourceName,
   return_to: z.string().optional(),
   client_id: z.string().optional(),
   client_secret: z.string().optional(),
@@ -2233,12 +2236,12 @@ var zSecretMaterial = z.discriminatedUnion("kind", [
 ]);
 var zCreateSecretRequest = z.object({
   owner: zSecretOwnerInput,
-  name: z.string().min(1),
+  name: zResourceName,
   metadata: zMetadata.optional(),
   material: zSecretMaterial
 });
 var zUpdateSecretRequest = z.object({
-  name: z.string().min(1).optional(),
+  name: zResourceName.optional(),
   metadata: zMetadata.optional()
 });
 var zSecretVersionRequest = z.object({
@@ -2258,7 +2261,7 @@ var zSecret = z.object({
   org_id: zOrganizationId,
   management_kind: zManagementKind,
   owner: zSecretOwner,
-  name: z.string(),
+  name: zResourceName,
   kind: zSecretKind,
   metadata: zMetadata,
   current_version_number: z.int().min(-2147483648, { error: "Invalid value: Expected int32 to be >= -2147483648" }).max(2147483647, { error: "Invalid value: Expected int32 to be <= 2147483647" }),
@@ -2299,11 +2302,11 @@ var zSecretGrant = z.object({
   created_at: zTimestamp
 });
 var zCreateOrganizationRequest = z.object({
-  name: z.string().min(1)
+  name: zResourceName
 });
 var zOrganization = z.object({
   id: zOrganizationId,
-  name: z.string(),
+  name: zResourceName,
   created_at: zTimestamp,
   updated_at: zTimestamp
 });
@@ -2316,7 +2319,7 @@ var zOrganizationMembership = z.object({
 var zOrgInvitation = z.object({
   id: zOrgInvitationId,
   org_id: zOrganizationId,
-  org_name: z.string(),
+  org_name: zResourceName,
   email: z.email(),
   org_role: z.string(),
   created_at: zTimestamp
@@ -2330,12 +2333,12 @@ var zCreateOrgInvitationRequest = z.object({
   role: z.string()
 });
 var zCreatePersonalAccessTokenRequest = z.object({
-  name: z.string().min(1)
+  name: zResourceName
 });
 var zPersonalAccessToken = z.object({
   id: zPersonalAccessTokenId,
   user_id: zUserId,
-  name: z.string(),
+  name: zResourceName,
   token_id: z.string(),
   created_at: zTimestamp,
   last_used_at: zTimestamp.nullable(),
@@ -2349,7 +2352,7 @@ var zOrgApiKeyRole = z.enum(["admin", "member"]);
 var zOrgApiKey = z.object({
   id: zOrgApiKeyId,
   org_id: zOrganizationId,
-  name: z.string(),
+  name: zResourceName,
   token_id: z.string(),
   org_role: z.string(),
   created_by_user_id: zUserId,
@@ -2359,7 +2362,7 @@ var zOrgApiKey = z.object({
   revoked_at: zTimestamp.nullable()
 });
 var zCreateOrgApiKeyRequest = z.object({
-  name: z.string().min(1),
+  name: zResourceName,
   org_role: zOrgApiKeyRole
 });
 var zCreateOrgApiKeyResponse = z.object({
@@ -2367,7 +2370,7 @@ var zCreateOrgApiKeyResponse = z.object({
   api_key: zOrgApiKey
 });
 var zUpdateOrgApiKeyRequest = z.object({
-  name: z.string().min(1).optional(),
+  name: zResourceName.optional(),
   org_role: zOrgApiKeyRole.optional()
 });
 var zListOrgApiKeysResponse = z.object({
@@ -2386,7 +2389,7 @@ var zArtifact = z.object({
   created_at: zTimestamp
 });
 var zCreateMachinePoolRequestBase = z.object({
-  name: z.string().min(1),
+  name: zResourceName,
   description: z.string().optional(),
   provider: z.string().min(1),
   default_machine_cpu: z.int().gte(1).lte(2147483647).optional(),
@@ -2405,6 +2408,7 @@ var zCreateMachinePoolRequestBase = z.object({
   min_machine_memory_mb: z.int().gte(0).lte(2147483647).optional(),
   max_machine_cpu: z.int().gte(1).lte(2147483647).optional(),
   max_machine_memory_mb: z.int().gte(1).lte(2147483647).optional(),
+  delete_after_idle_minutes: z.int().gte(5).lte(2147483647).optional(),
   metadata: zMachineMetadata.optional()
 });
 var zCreateMachinePoolRequest = zCreateMachinePoolRequestBase.and(z.union([
@@ -2432,7 +2436,7 @@ var zCreateMachinePoolRequest = zCreateMachinePoolRequestBase.and(z.union([
   })
 ]));
 var zUpdateMachinePoolRequest = z.object({
-  name: z.string().min(1).optional(),
+  name: zResourceName.optional(),
   description: z.string().optional(),
   default_machine_cpu: z.int().gte(1).lte(2147483647).nullish(),
   default_machine_memory_mb: z.int().gte(1).lte(2147483647).nullish(),
@@ -2450,6 +2454,7 @@ var zUpdateMachinePoolRequest = z.object({
   min_machine_memory_mb: z.int().gte(0).lte(2147483647).nullish(),
   max_machine_cpu: z.int().gte(1).lte(2147483647).nullish(),
   max_machine_memory_mb: z.int().gte(1).lte(2147483647).nullish(),
+  delete_after_idle_minutes: z.int().gte(5).lte(2147483647).nullish(),
   metadata: zMachineMetadata.optional()
 });
 var zMachinePoolUsage = z.object({
@@ -2460,7 +2465,7 @@ var zMachinePoolUsage = z.object({
 var zMachinePool = z.object({
   id: zMachinePoolId,
   org_id: zOrganizationId,
-  name: z.string(),
+  name: zResourceName,
   management_kind: zManagementKind,
   description: z.string(),
   provider: z.string(),
@@ -2480,6 +2485,7 @@ var zMachinePool = z.object({
   min_machine_memory_mb: z.int().gte(0).lte(2147483647).nullable(),
   max_machine_cpu: z.int().gte(1).lte(2147483647).nullable(),
   max_machine_memory_mb: z.int().gte(1).lte(2147483647).nullable(),
+  delete_after_idle_minutes: z.int().gte(5).lte(2147483647).nullable(),
   metadata: zMetadata,
   created_at: zTimestamp,
   updated_at: zTimestamp,
@@ -2510,7 +2516,7 @@ var zMachine = z.object({
   org_id: zOrganizationId,
   source_kind: zMachineSourceKind,
   machine_pool_id: zMachinePoolId.nullish(),
-  display_name: z.string(),
+  display_name: zResourceName,
   description: z.string(),
   provider: z.string(),
   lifecycle_state: zMachineLifecycleState,
@@ -2532,7 +2538,7 @@ var zMachine = z.object({
   updated_at: zTimestamp
 });
 var zCreateMachineRequest = z.object({
-  display_name: z.string().min(1),
+  display_name: zResourceName,
   description: z.string().optional(),
   cwd: z.string().optional(),
   env: z.record(z.string(), z.string()).optional(),
@@ -2540,8 +2546,14 @@ var zCreateMachineRequest = z.object({
   metadata: zMachineMetadata.optional()
 });
 var zConnectByoMachineRequest = z.object({
-  display_name: z.string().min(1),
-  project_ids: z.array(zProjectId).max(100)
+  display_name: zResourceName,
+  description: z.string().optional(),
+  cwd: z.string().optional(),
+  env: z.record(z.string(), z.string()).optional(),
+  secret_env: z.record(z.string(), zSecretId).optional(),
+  metadata: zMachineMetadata.optional(),
+  project_ids: z.array(zProjectId).max(100).optional(),
+  token_name: zResourceName.optional()
 });
 var zUpdateMachineRequest = z.object({
   cwd: z.string().optional(),
@@ -2552,7 +2564,7 @@ var zMachineSummaryFields = z.object({
   id: zMachineId,
   org_id: zOrganizationId,
   source_kind: zMachineSourceKind,
-  display_name: z.string(),
+  display_name: zResourceName,
   description: z.string(),
   provider: z.string(),
   lifecycle_state: zMachineLifecycleState,
@@ -2628,6 +2640,10 @@ var zProjectMachinePoolGrant = z.object({
   min_machine_memory_mb: z.int().gte(0).lte(2147483647).nullable(),
   max_machine_cpu: z.int().gte(1).lte(2147483647).nullable(),
   max_machine_memory_mb: z.int().gte(1).lte(2147483647).nullable(),
+  delete_after_idle_minutes: z.union([
+    z.literal(0),
+    z.int().gte(5).lte(2147483647)
+  ]).nullable(),
   metadata: zMetadata,
   created_at: zTimestamp,
   updated_at: zTimestamp
@@ -2648,6 +2664,10 @@ var zCreateProjectMachinePoolGrantRequest = z.object({
   min_machine_memory_mb: z.int().gte(0).lte(2147483647).optional(),
   max_machine_cpu: z.int().gte(1).lte(2147483647).optional(),
   max_machine_memory_mb: z.int().gte(1).lte(2147483647).optional(),
+  delete_after_idle_minutes: z.union([
+    z.literal(0),
+    z.int().gte(5).lte(2147483647)
+  ]).optional(),
   metadata: zMetadata.optional()
 });
 var zUpdateProjectMachinePoolGrantRequest = z.object({
@@ -2665,12 +2685,16 @@ var zUpdateProjectMachinePoolGrantRequest = z.object({
   min_machine_memory_mb: z.int().gte(0).lte(2147483647).nullish(),
   max_machine_cpu: z.int().gte(1).lte(2147483647).nullish(),
   max_machine_memory_mb: z.int().gte(1).lte(2147483647).nullish(),
+  delete_after_idle_minutes: z.union([
+    z.literal(0),
+    z.int().gte(5).lte(2147483647)
+  ]).nullish(),
   metadata: zMetadata.optional()
 });
 var zMachinePoolSummary = z.object({
   id: zMachinePoolId,
   org_id: zOrganizationId,
-  name: z.string(),
+  name: zResourceName,
   management_kind: zManagementKind,
   description: z.string(),
   provider: z.string(),
@@ -2686,14 +2710,14 @@ var zListProjectMachinePoolGrantsResponse = z.object({
   next_cursor: z.string().nullable()
 });
 var zCreateMachineDaemonTokenRequest = z.object({
-  name: z.string().optional(),
+  name: zResourceName.optional(),
   metadata: zMetadata.optional()
 });
 var zMachineDaemonToken = z.object({
   id: zMachineDaemonTokenId,
   org_id: zOrganizationId,
   machine_id: zMachineId,
-  name: z.string(),
+  name: zResourceName,
   metadata: zMetadata,
   created_at: zTimestamp,
   last_used_at: zTimestamp.nullable(),
@@ -2803,12 +2827,12 @@ var zBootstrapDaemonResponse = z.object({
   machine_id: zMachineId
 });
 var zCreateProjectRequest = z.object({
-  name: z.string().min(1)
+  name: zResourceName
 });
 var zProjectFields = z.object({
   id: zProjectId,
   org_id: zOrganizationId,
-  name: z.string(),
+  name: zResourceName,
   created_at: zTimestamp,
   updated_at: zTimestamp
 });
@@ -2859,7 +2883,7 @@ var zCurrentUserIdentity = z.object({
 });
 var zCurrentUserOrg = z.object({
   id: zOrganizationId,
-  name: z.string(),
+  name: zResourceName,
   role: z.string(),
   created_at: zTimestamp
 });
@@ -2890,7 +2914,7 @@ var zSetProjectMembershipRequest = z.object({
 });
 var zProjectMembershipGrant = z.object({
   project_id: zProjectId,
-  project_name: z.string(),
+  project_name: zResourceName,
   role: z.string(),
   created_at: zTimestamp
 });
@@ -3274,7 +3298,6 @@ var zListAgentProfilesQuery = z.object({
   cursor: z.string().max(1024).optional()
 });
 var zListAgentProfilesResponse2 = zListAgentProfilesResponse;
-var zCreateAgentProfileBody = zCreateAgentProfileRequest;
 var zCreateAgentProfileHeaders = z.object({
   "Idempotency-Key": z.string().min(1).max(255).optional()
 });
@@ -3376,7 +3399,6 @@ var zListAgentsQuery = z.object({
   cursor: z.string().max(1024).optional()
 });
 var zListAgentsResponse2 = zListAgentsResponse;
-var zCreateAgentBody = zCreateAgentRequest;
 var zCreateAgentHeaders = z.object({
   "Idempotency-Key": z.string().min(1).max(255).optional()
 });
@@ -3656,7 +3678,6 @@ var zListVisibleMachinesQuery = z.object({
   cursor: z.string().max(1024).optional()
 });
 var zListVisibleMachinesResponse2 = zListVisibleMachinesResponse;
-var zCreateMachineBody = zCreateMachineRequest;
 var zCreateMachineHeaders = z.object({
   "Idempotency-Key": z.string().min(1).max(255).optional()
 });
@@ -3664,6 +3685,7 @@ var zCreateMachinePath = z.object({
   orgID: z.string().regex(/^org_[a-z2-7]{26}$/)
 });
 var zCreateMachineResponse = zMachine;
+var zConnectByoMachineBody = zConnectByoMachineRequest;
 var zConnectByoMachinePath = z.object({
   orgID: zOrganizationId
 });
@@ -5677,11 +5699,19 @@ var createMachine = (options) => (options.client ?? client).post({
 });
 var connectByoMachine = (options) => (options.client ?? client).post({
   responseValidator: async (data) => await validateResponse(zConnectByoMachineResponse2, data),
-  security: [{
-    in: "cookie",
-    name: "__Host-omnara_session",
-    type: "apiKey"
-  }, { name: "X-Omnara-Csrf", type: "apiKey" }],
+  security: [
+    {
+      key: "bearerAuth",
+      scheme: "bearer",
+      type: "http"
+    },
+    {
+      in: "cookie",
+      name: "__Host-omnara_session",
+      type: "apiKey"
+    },
+    { name: "X-Omnara-Csrf", type: "apiKey" }
+  ],
   url: "/api/v1/orgs/{orgID}/machines/connect",
   ...options,
   headers: {
@@ -6289,10 +6319,10 @@ var getDaemonSkillArchive = (options) => (options.client ?? client).get({
 
 // ../sdk/src/auth.ts
 function bearerToken(token) {
-  const resolve2 = typeof token === "function" ? token : () => token;
+  const resolve3 = typeof token === "function" ? token : () => token;
   return {
     async authenticate(request) {
-      const value = await resolve2();
+      const value = await resolve3();
       if (value) request.headers.set("Authorization", `Bearer ${value}`);
     }
   };
@@ -6330,6 +6360,32 @@ var ApiError = class _ApiError extends Error {
 };
 
 // ../sdk/src/client.ts
+function stripClientSelector(client2) {
+  const strip = (dispatch) => (options) => {
+    if (options == null || !("client" in options)) return dispatch(options);
+    const rest = { ...options };
+    delete rest.client;
+    return dispatch(rest);
+  };
+  const methods = [
+    "connect",
+    "delete",
+    "get",
+    "head",
+    "options",
+    "patch",
+    "post",
+    "put",
+    "request",
+    "trace"
+  ];
+  const wrap = (target) => {
+    const dispatches = target;
+    for (const method of methods) dispatches[method] &&= strip(dispatches[method]);
+  };
+  wrap(client2);
+  wrap(client2.sse);
+}
 function createOmnaraClient(options = {}) {
   const client2 = createClient(
     createConfig({
@@ -6352,6 +6408,7 @@ function createOmnaraClient(options = {}) {
     if (!response.ok) throw await ApiError.fromResponse(response);
     return response;
   });
+  stripClientSelector(client2);
   return client2;
 }
 
@@ -6413,7 +6470,7 @@ async function startDeviceAuth(options) {
   };
 }
 function defaultSleep(seconds) {
-  return new Promise((resolve2) => setTimeout(resolve2, seconds * 1e3));
+  return new Promise((resolve3) => setTimeout(resolve3, seconds * 1e3));
 }
 async function pollDeviceAuthToken(options) {
   const fetchImpl = options.fetch ?? fetch;
@@ -7009,6 +7066,7 @@ function flowOp(spec) {
     type: "flow",
     execute: (input) => run({
       client: input.client,
+      baseUrl: input.baseUrl,
       path: parseWithSchema(spec.path, input.path, "arguments"),
       body: parseWithSchema(spec.body, input.body, "flags"),
       report: createFlowReporter(spec.summary)
@@ -7208,14 +7266,17 @@ function registerOperation(parent, config2, spec) {
         const base = options.body === void 0 ? {} : parseWithSchema(zBodyObject, options.body, "--body");
         const body = deepMerge(base, collectFlagValues(bodyFlags, options));
         const parsed = parseWithSchema(spec.body, body, "request body");
-        input.body = spec.transformBody ? await spec.transformBody(parsed) : parsed;
+        input.body = spec.transformBody ? await spec.transformBody(parsed, {
+          client: config2.client,
+          path: input.path ?? {}
+        }) : parsed;
       }
       const data = await callOperation(spec, input);
       if (options.json === true) {
         renderResult(data, true);
         return;
       }
-      const formatted = spec.format(data);
+      const formatted = spec.format(data, { baseUrl: config2.baseUrl });
       renderResult(formatted.value, false, { columns: formatted.columns });
     });
   });
@@ -7231,6 +7292,7 @@ function registerFlow(parent, config2, spec) {
       const options = command.opts();
       await spec.execute({
         client: config2.client,
+        baseUrl: config2.baseUrl,
         path: await resolvePathValues(plan, args, options, config2),
         body: collectFlagValues(bodyFlags, options)
       });
@@ -7249,6 +7311,7 @@ function registerGroup(program2, config2, group) {
 // src/login.ts
 import { hostname } from "node:os";
 import { intro as intro2, log as log2, note as note2, outro as outro2, spinner as spinner2 } from "@clack/prompts";
+import * as z7 from "zod";
 
 // src/browser.ts
 import { spawn } from "node:child_process";
@@ -7346,6 +7409,14 @@ function plainReporter2() {
     }
   };
 }
+function loginTokenName(explicit, hostName) {
+  const candidate = explicit ?? `Omnara CLI on ${hostName}`;
+  const result = zResourceName.safeParse(candidate);
+  if (result.success) return result.data;
+  if (explicit === void 0) return "Omnara CLI";
+  throw new CliInputError(`invalid token name:
+${z7.prettifyError(result.error)}`);
+}
 function registerLoginCommand(program2, cli) {
   program2.command("login").description("Log in via the browser and save an API token").option("--no-browser", "print the approval URL instead of opening a browser").option("--token-name <name>", "name for the created API token").action(async (options) => {
     await runCliAction(async () => {
@@ -7354,7 +7425,7 @@ function registerLoginCommand(program2, cli) {
       const start = await startDeviceAuth({
         baseUrl: cli.baseUrl,
         clientName: "Omnara CLI",
-        tokenName: options.tokenName ?? `Omnara CLI on ${hostname()}`
+        tokenName: loginTokenName(options.tokenName, hostname())
       });
       report.showCode(start.userCode, start.verificationUriComplete);
       if (options.browser) {
@@ -7424,7 +7495,75 @@ function registerLoginCommand(program2, cli) {
 }
 
 // src/manifest.ts
-import * as z11 from "zod";
+import * as z14 from "zod";
+
+// src/config-attachment.ts
+import { readFileSync as readFileSync2 } from "node:fs";
+import * as z8 from "zod";
+var zConfigSourceAttachment = z8.object({
+  file: z8.string().min(1).optional().describe("path to an agent config file (.yaml, .yml, or .json)"),
+  source: z8.string().min(1).optional().describe("inline agent config source (YAML or JSON)")
+});
+var zConfigAttachment = z8.object({
+  config: zAgentConfigId.optional().describe("existing agent config ID"),
+  ...zConfigSourceAttachment.shape
+});
+var ATTACHMENT_HINT = "pass exactly one of --config, --file, or --source";
+var SOURCE_HINT = "pass exactly one of --file or --source";
+function requireExactlyOne(values, hint) {
+  const provided = values.filter((value) => value !== void 0);
+  if (provided.length !== 1) throw new CliInputError(hint);
+}
+function fileFormat(filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower.endsWith(".json")) return "json";
+  if (lower.endsWith(".yaml") || lower.endsWith(".yml")) return "yaml";
+  throw new CliInputError(`config file must end in .yaml, .yml, or .json: ${filePath}`);
+}
+function inlineFormat(source) {
+  try {
+    JSON.parse(source);
+    return "json";
+  } catch {
+    return "yaml";
+  }
+}
+function renderConfigSource(attachment) {
+  requireExactlyOne([attachment.file, attachment.source], SOURCE_HINT);
+  if (attachment.file !== void 0) {
+    const format = fileFormat(attachment.file);
+    let source;
+    try {
+      source = readFileSync2(attachment.file, "utf8");
+    } catch {
+      throw new CliInputError(`could not read config file: ${attachment.file}`);
+    }
+    return { source, source_format: format };
+  }
+  if (attachment.source !== void 0) {
+    return { source: attachment.source, source_format: inlineFormat(attachment.source) };
+  }
+  throw new CliInputError(SOURCE_HINT);
+}
+var zProjectScope = z8.object({
+  orgID: z8.string().min(1),
+  projectID: z8.string().min(1)
+});
+async function resolveConfigId(client2, path, attachment) {
+  requireExactlyOne([attachment.config, attachment.file, attachment.source], ATTACHMENT_HINT);
+  if (attachment.config !== void 0) return attachment.config;
+  const { data } = await sdk_gen_exports.createAgentConfig({
+    client: client2,
+    path: zProjectScope.parse(path),
+    body: renderConfigSource(attachment)
+  });
+  return data.id;
+}
+var zProfilePath = zProjectScope.extend({ agentProfileID: z8.string().min(1) });
+async function currentProfileConfigId(client2, path) {
+  const { data } = await sdk_gen_exports.getAgentProfile({ client: client2, path: zProfilePath.parse(path) });
+  return data.current_config_id;
+}
 
 // src/format.ts
 function pickFields(source, fields) {
@@ -7451,18 +7590,332 @@ function formatVoid(message = "ok") {
   return () => ({ value: message });
 }
 
+// src/machine-setup.ts
+import { spawn as spawn2, spawnSync } from "node:child_process";
+import { accessSync, constants, existsSync as existsSync2, readdirSync, readFileSync as readFileSync3 } from "node:fs";
+import { homedir as homedir2 } from "node:os";
+import { basename, dirname as dirname2, isAbsolute, join as join2, resolve } from "node:path";
+import * as z9 from "zod";
+var zMachineSetupBody = zConnectByoMachineRequest;
+async function connectMachine(context) {
+  const { client: client2, path, body, report } = context;
+  report.start("Creating machine with a daemon token");
+  try {
+    const { data } = await sdk_gen_exports.connectByoMachine({ client: client2, path, body });
+    report.stop(`Machine created: ${data.machine.id}`);
+    if (data.project_grants.length > 0) {
+      report.info(`Granted to ${data.project_grants.length} project(s)`);
+    }
+    return data;
+  } catch (error) {
+    report.fail("Machine could not be created");
+    throw error;
+  }
+}
+function shellQuote(value) {
+  return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+function installCommand(baseUrl) {
+  return `curl -fsSL ${shellQuote(`${baseUrl}/install/omnarad.sh`)} | sh`;
+}
+var formatMachineSetup = (response, { baseUrl }) => ({
+  value: {
+    ...response,
+    install_command: installCommand(baseUrl),
+    install_note: "Run install_command on the target machine and paste the token when prompted."
+  }
+});
+var daemonConfigFileName = "daemon.json";
+var installLockFileName = "install.lock";
+var daemonLockFileName = "daemon.lock";
+var daemonLockPollMs = 250;
+var zDaemonConfigFile = z9.looseObject({
+  machine_id: z9.string().optional(),
+  api_url: z9.string().optional()
+});
+function daemonHome() {
+  const override = process.env.OMNARA_HOME;
+  if (override !== void 0 && override !== "") {
+    if (!isAbsolute(override) || resolve(override) !== override) {
+      throw new CliInputError("OMNARA_HOME must be an absolute clean path");
+    }
+    if (dirname2(override) === override) {
+      throw new CliInputError("OMNARA_HOME cannot be a filesystem root");
+    }
+    return override;
+  }
+  const userHome = homedir2();
+  if (userHome === "" || !isAbsolute(userHome) || userHome.trim() !== userHome) {
+    throw new CliInputError("HOME must be an absolute path so omnarad can install under ~/.omnarad");
+  }
+  return join2(userHome, ".omnarad");
+}
+var supportedPlatforms = /* @__PURE__ */ new Set(["darwin", "linux"]);
+var supportedArchitectures = /* @__PURE__ */ new Set(["x64", "arm64"]);
+function ensureSupportedPlatform(platform, architecture) {
+  if (!supportedPlatforms.has(platform)) {
+    throw new CliInputError(`omnarad supports macOS and Linux; this machine reports ${platform}`);
+  }
+  if (!supportedArchitectures.has(architecture)) {
+    throw new CliInputError(
+      `omnarad supports amd64 and arm64; this machine reports ${architecture}`
+    );
+  }
+}
+function isLoopbackHost(hostname2) {
+  if (hostname2 === "localhost" || hostname2 === "[::1]" || hostname2 === "::1") return true;
+  const octets = hostname2.split(".");
+  return octets.length === 4 && octets[0] === "127" && octets.every((octet) => /^\d{1,3}$/.test(octet));
+}
+function ensureDaemonApiUrl(raw) {
+  const trimmed = raw.trim();
+  let parsed;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw new CliInputError(`omnarad rejects the API URL ${raw}: it must be an absolute URL`);
+  }
+  const reject = (reason) => {
+    throw new CliInputError(`omnarad rejects the API URL ${raw}: ${reason}`);
+  };
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:") {
+    reject("the scheme must be https or loopback http");
+  }
+  if (parsed.hostname === "") reject("a host is required");
+  if (parsed.username !== "" || parsed.password !== "") reject("it must not contain user info");
+  if (trimmed.includes("?") || trimmed.includes("#")) {
+    reject("it must not contain a query or fragment");
+  }
+  const hostname2 = parsed.hostname.toLowerCase();
+  if (parsed.protocol === "http:" && hostname2 !== "host.docker.internal" && !isLoopbackHost(hostname2)) {
+    reject("it must use https unless the host is local");
+  }
+}
+function describeDaemonConfig(configPath) {
+  try {
+    const config2 = zDaemonConfigFile.parse(JSON.parse(readFileSync3(configPath, "utf8")));
+    const details = [
+      ...config2.machine_id === void 0 ? [] : [`machine ${config2.machine_id}`],
+      ...config2.api_url === void 0 ? [] : [`API ${config2.api_url}`]
+    ];
+    return details.length === 0 ? configPath : `${configPath} (${details.join(", ")})`;
+  } catch {
+    return configPath;
+  }
+}
+function describeExistingInstallation(home) {
+  const configPath = join2(home, daemonConfigFileName);
+  if (existsSync2(configPath)) return describeDaemonConfig(configPath);
+  if (!existsSync2(home)) return void 0;
+  const leftovers = readdirSync(home).filter((name) => name !== installLockFileName);
+  return leftovers.length === 0 ? void 0 : `${home} already contains ${leftovers.join(", ")}`;
+}
+function nearestExistingAncestor(path) {
+  const parent = dirname2(path);
+  return existsSync2(path) || parent === path ? path : nearestExistingAncestor(parent);
+}
+function ensureDaemonHomeWritable(home) {
+  const target = nearestExistingAncestor(home);
+  try {
+    accessSync(target, constants.W_OK);
+  } catch {
+    throw new CliInputError(`omnarad cannot be installed because ${target} is not writable`);
+  }
+}
+var DaemonExitError = class extends Error {
+};
+async function runMachineCreateLocal(context) {
+  const { report, baseUrl } = context;
+  ensureSupportedPlatform(process.platform, process.arch);
+  ensureDaemonApiUrl(baseUrl);
+  const home = daemonHome();
+  const existing = describeExistingInstallation(home);
+  if (existing !== void 0) {
+    report.warn(`omnarad is already installed on this computer: ${existing}`);
+    report.info(
+      [
+        "Nothing was created. Check the daemon with: omnarad status, or start it with: omnarad restart",
+        "To connect this computer as a new machine, run: omnarad uninstall, then re-run this command"
+      ].join("\n")
+    );
+    throw new CliInputError("omnarad is already installed on this machine");
+  }
+  ensureDaemonHomeWritable(home);
+  const { machine, token } = await connectMachine(context);
+  report.info(`Machine ID: ${machine.id}`);
+  report.start("Installing omnarad on this machine");
+  try {
+    await runInstaller(report, baseUrl, token, machine.id, home);
+  } catch (error) {
+    if (error instanceof DaemonExitError) {
+      report.fail("omnarad exited after it was installed");
+      report.info(
+        [
+          `omnarad is installed and registered as machine ${machine.id}; nothing needs to be reinstalled.`,
+          "Check the daemon with: omnarad status, or launch it again with: omnarad start"
+        ].join("\n")
+      );
+      throw error;
+    }
+    report.fail("omnarad installation failed");
+    report.info(`Machine daemon token (shown only once):
+${token}`);
+    report.url(
+      "Finish setup by running this, then paste the machine token when prompted",
+      installCommand(baseUrl)
+    );
+    throw error;
+  }
+  report.done();
+}
+function daemonGuidance(machineId) {
+  return [
+    "omnarad is connected to Omnara as this machine.",
+    "Manage the daemon with: omnarad status | stop | restart | uninstall",
+    `Let agents in a project use this machine with: omnara grant machines add --machine-id ${machineId}`,
+    "Learn more: https://docs.omnara.com/machines/connect"
+  ].join("\n");
+}
+var foregroundGuidance = [
+  "No launchd/systemd user service manager is available, so omnarad is running in the foreground.",
+  "Its logs stream below; press Ctrl-C to stop the daemon, and run omnarad start to launch it again."
+].join("\n");
+var serviceManagerCommands = /* @__PURE__ */ new Set(["launchd", "systemd"]);
+function parentProcess(pid) {
+  if (process.platform === "linux") {
+    try {
+      const stat = readFileSync3(`/proc/${pid}/stat`, "utf8");
+      const fields = stat.slice(stat.lastIndexOf(")") + 2).split(" ");
+      const ppid2 = Number(fields[1]);
+      const parentStat = readFileSync3(`/proc/${ppid2}/stat`, "utf8");
+      const command = parentStat.slice(parentStat.indexOf("(") + 1, parentStat.lastIndexOf(")"));
+      return Number.isInteger(ppid2) && ppid2 > 0 ? { pid: ppid2, command } : void 0;
+    } catch {
+      return void 0;
+    }
+  }
+  const result = spawnSync("ps", ["-o", "ppid=", "-p", String(pid)], { encoding: "utf8" });
+  const ppid = Number(result.stdout.trim());
+  if (result.status !== 0 || !Number.isInteger(ppid) || ppid <= 0) return void 0;
+  const parent = spawnSync("ps", ["-o", "comm=", "-p", String(ppid)], { encoding: "utf8" });
+  return { pid: ppid, command: basename(parent.stdout.trim()) };
+}
+function classifyDaemonSupervision(daemonPid, installerPid, lookupParent) {
+  let current = daemonPid;
+  for (let depth = 0; depth < 16; depth += 1) {
+    const parent = lookupParent(current);
+    if (parent === void 0) return void 0;
+    if (parent.pid === installerPid) return "foreground";
+    if (parent.pid === 1 || serviceManagerCommands.has(parent.command)) return "service";
+    current = parent.pid;
+  }
+  return void 0;
+}
+function readDaemonLockPid(home) {
+  try {
+    const pid = Number(readFileSync3(join2(home, daemonLockFileName), "utf8").trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function installerScript(baseUrl) {
+  return [
+    "installer=$(mktemp)",
+    `trap 'rm -f "$installer"' EXIT`,
+    `curl -qfsSL --connect-timeout 10 -m 60 --max-redirs 5 --max-filesize 1048576 --proto '=http,https' --proto-redir '=https' -o "$installer" ${shellQuote(`${baseUrl}/install/omnarad.sh`)}`,
+    'sh "$installer"'
+  ].join(" && ");
+}
+function installerFailure(code, signal, log3) {
+  const reason = signal === null ? `exit code ${code}` : `signal ${signal}`;
+  return new Error(`omnarad installer failed (${reason})${log3 === "" ? "" : `
+${log3}`}`);
+}
+function runInstaller(report, baseUrl, token, machineId, home) {
+  return new Promise((resolve3, reject) => {
+    const child = spawn2("/bin/sh", ["-c", installerScript(baseUrl)], {
+      stdio: ["ignore", "pipe", "pipe"],
+      env: { ...process.env, OMNARA_API_URL: baseUrl, OMNARA_MACHINE_TOKEN: token }
+    });
+    const relay = (signal) => {
+      child.kill(signal);
+    };
+    process.on("SIGINT", relay);
+    process.on("SIGTERM", relay);
+    const buffered = [];
+    let transcript = "";
+    let supervision;
+    const enterForeground = () => {
+      supervision = "foreground";
+      report.stop("omnarad installed");
+      report.info(daemonGuidance(machineId));
+      report.info(foregroundGuidance);
+      for (const [target, data] of buffered) target.write(data);
+    };
+    const lockWatch = setInterval(() => {
+      if (supervision !== void 0 || child.pid === void 0) return;
+      const daemonPid = readDaemonLockPid(home);
+      if (daemonPid === void 0) return;
+      const detected = classifyDaemonSupervision(daemonPid, child.pid, parentProcess);
+      if (detected === "foreground") enterForeground();
+      else if (detected === "service") supervision = "service";
+    }, daemonLockPollMs);
+    const settle = (outcome) => {
+      clearInterval(lockWatch);
+      process.off("SIGINT", relay);
+      process.off("SIGTERM", relay);
+      outcome();
+    };
+    const consume = (stream) => (chunk) => {
+      if (supervision === "foreground") {
+        stream.write(chunk);
+        return;
+      }
+      buffered.push([stream, chunk]);
+      transcript += chunk.toString();
+    };
+    child.stdout.on("data", consume(process.stdout));
+    child.stderr.on("data", consume(process.stderr));
+    child.on("error", (error) => {
+      settle(() => {
+        reject(new Error(`could not run the omnarad installer: ${error.message}`));
+      });
+    });
+    child.on("close", (code, signal) => {
+      settle(() => {
+        const foreground = supervision === "foreground";
+        if (foreground && (code === 0 || signal === "SIGINT")) {
+          report.info("omnarad stopped");
+          resolve3();
+        } else if (foreground) {
+          const reason = signal === null ? `exit code ${code}` : `signal ${signal}`;
+          reject(new DaemonExitError(`omnarad exited while running in the foreground (${reason})`));
+        } else if (code === 0) {
+          report.stop("omnarad installed and started as a background service");
+          for (const [target, data] of buffered) target.write(data);
+          report.info(daemonGuidance(machineId));
+          resolve3();
+        } else {
+          reject(installerFailure(code, signal, transcript.trim()));
+        }
+      });
+    });
+  });
+}
+
 // src/mcp-add.ts
 import { isMap, isScalar as isScalar2, parseDocument } from "yaml";
-import * as z8 from "zod";
+import * as z11 from "zod";
 
 // src/mcp-oauth.ts
-import * as z7 from "zod";
+import * as z10 from "zod";
 
 // src/poll.ts
 var POLL_INTERVAL_SECONDS = 2;
 var MAX_CONSECUTIVE_POLL_FAILURES = 3;
 function sleep(seconds) {
-  return new Promise((resolve2) => setTimeout(resolve2, seconds * 1e3));
+  return new Promise((resolve3) => setTimeout(resolve3, seconds * 1e3));
 }
 async function pollUntilDeadline(options) {
   const deadline = Date.parse(options.expiresAt);
@@ -7504,7 +7957,7 @@ async function authorizeMcpOAuthSecret(options) {
     }
   });
 }
-var zBrowserFlag = z7.boolean().default(true).describe("open the authorization URL in a browser");
+var zBrowserFlag = z10.boolean().default(true).describe("open the authorization URL in a browser");
 function openAuthorizationUrl(report, title, url3, browser) {
   report.url(title, url3);
   if (browser) {
@@ -7540,11 +7993,11 @@ async function runMcpOAuth(context) {
 // src/mcp-add.ts
 var SERVER_KEY_PATTERN = /^[a-zA-Z][a-zA-Z0-9-]{0,31}$/;
 var zMcpAddBody = zMcpoAuthStartRequest.omit({ owner: true, name: true }).extend({
-  server_name: z8.string().regex(
+  server_name: z11.string().regex(
     SERVER_KEY_PATTERN,
     "must start with a letter and contain at most 32 letters, digits, or hyphens"
   ).describe("MCP server key used in the agent config"),
-  secret_name: z8.string().min(1).optional().describe("OAuth secret name; defaults to <server-name>-mcp"),
+  secret_name: zResourceName.optional().describe("OAuth secret name; defaults to <server-name>-mcp"),
   browser: zBrowserFlag
 });
 function targetLabel(target) {
@@ -7553,7 +8006,7 @@ function targetLabel(target) {
 function serverEntry(url3, secretId) {
   return { url: url3, auth: { type: "oauth", secret_id: secretId } };
 }
-var zJsonRecord = z8.record(z8.string(), z8.json());
+var zJsonRecord = z11.record(z11.string(), z11.json());
 function prepareJsonConfig(config2, serverName, mcpUrl) {
   let parsedJson;
   try {
@@ -7717,18 +8170,18 @@ function runProfileMcpAdd(context) {
 }
 
 // src/skill-archive.ts
-import { readdirSync, readFileSync as readFileSync2, statSync } from "node:fs";
-import { basename, dirname as dirname2, join as join2, resolve } from "node:path";
+import { readdirSync as readdirSync2, readFileSync as readFileSync4, statSync } from "node:fs";
+import { basename as basename2, dirname as dirname3, join as join3, resolve as resolve2 } from "node:path";
 import * as tar from "tar";
-import * as z9 from "zod";
-var zCreateSkillCliBody = z9.object({
+import * as z12 from "zod";
+var zCreateSkillCliBody = z12.object({
   owner: zSkillOwnerInput,
-  archive: z9.string().min(1).describe("path to a skill directory (packed automatically) or a .zip/.tar.gz archive")
+  archive: z12.string().min(1).describe("path to a skill directory (packed automatically) or a .zip/.tar.gz archive")
 });
 var ARCHIVE_SUFFIXES = [".zip", ".tar.gz", ".tgz"];
 function assertPackable(dir) {
-  for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const fullPath = join2(dir, entry.name);
+  for (const entry of readdirSync2(dir, { withFileTypes: true })) {
+    const fullPath = join3(dir, entry.name);
     if (entry.isSymbolicLink()) {
       throw new CliInputError(`cannot pack ${fullPath}: symlinks are not allowed in skill archives`);
     }
@@ -7737,9 +8190,9 @@ function assertPackable(dir) {
   }
 }
 async function packDirectory(dir) {
-  const root = resolve(dir);
+  const root = resolve2(dir);
   assertPackable(root);
-  const stream = tar.create({ cwd: dirname2(root), gzip: true, portable: true }, [basename(root)]);
+  const stream = tar.create({ cwd: dirname3(root), gzip: true, portable: true }, [basename2(root)]);
   const chunks = [];
   for await (const chunk of stream) chunks.push(chunk);
   return Buffer.concat(chunks);
@@ -7753,28 +8206,28 @@ async function loadSkillArchive(archivePath) {
   }
   if (isDirectory) {
     const buffer = await packDirectory(archivePath);
-    return new File([new Uint8Array(buffer)], `${basename(resolve(archivePath))}.tar.gz`);
+    return new File([new Uint8Array(buffer)], `${basename2(resolve2(archivePath))}.tar.gz`);
   }
-  const filename = basename(archivePath);
+  const filename = basename2(archivePath);
   if (!ARCHIVE_SUFFIXES.some((suffix) => filename.toLowerCase().endsWith(suffix))) {
     throw new CliInputError(
       `archive must be a directory or a ${ARCHIVE_SUFFIXES.join("/")} file: ${archivePath}`
     );
   }
-  return new File([new Uint8Array(readFileSync2(archivePath))], filename);
+  return new File([new Uint8Array(readFileSync4(archivePath))], filename);
 }
 
 // src/slack-integration.ts
-import * as z10 from "zod";
-var zSlackBody = z10.object({
-  app_name: z10.string().optional().describe("name for a new Slack app"),
-  app_configuration_token: z10.string().optional().describe("Slack app configuration token for a new app"),
-  icon_filename: z10.string().optional().describe("filename for the new Slack app icon"),
-  icon_data_base64: z10.string().optional().describe("base64-encoded Slack app icon"),
-  client_id: z10.string().optional().describe("existing Slack app client ID"),
-  client_secret: z10.string().optional().describe("existing Slack app client secret"),
-  signing_secret: z10.string().optional().describe("existing Slack app signing secret"),
-  return_to: z10.string().optional().describe("console-relative path opened after authorization"),
+import * as z13 from "zod";
+var zSlackBody = z13.object({
+  app_name: z13.string().optional().describe("name for a new Slack app"),
+  app_configuration_token: z13.string().optional().describe("Slack app configuration token for a new app"),
+  icon_filename: z13.string().optional().describe("filename for the new Slack app icon"),
+  icon_data_base64: z13.string().optional().describe("base64-encoded Slack app icon"),
+  client_id: z13.string().optional().describe("existing Slack app client ID"),
+  client_secret: z13.string().optional().describe("existing Slack app client secret"),
+  signing_secret: z13.string().optional().describe("existing Slack app signing secret"),
+  return_to: z13.string().optional().describe("console-relative path opened after authorization"),
   browser: zBrowserFlag
 });
 function parseRequest(body) {
@@ -7803,7 +8256,7 @@ function parseRequest(body) {
     if (!result2.success) {
       throw new CliInputError(
         `invalid existing Slack app parameters:
-${z10.prettifyError(result2.error)}`
+${z13.prettifyError(result2.error)}`
       );
     }
     return { kind: "existing-app", body: result2.data };
@@ -7825,7 +8278,7 @@ ${z10.prettifyError(result2.error)}`
   if (!result.success) {
     throw new CliInputError(
       `invalid Slack app parameters:
-${z10.prettifyError(result.error)}
+${z13.prettifyError(result.error)}
 Pass --app-name and --app-configuration-token, or existing app credentials.`
     );
   }
@@ -7917,7 +8370,31 @@ var commandGroups = [
         fn: sdk_gen_exports.createAgent,
         format: formatRecord(),
         path: zCreateAgentPath,
-        body: zCreateAgentBody
+        body: zConfigAttachment.extend({
+          profile: zAgentProfileId.optional(),
+          name: zAgentName.optional(),
+          message: z14.string().optional()
+        }),
+        transformBody: async ({ profile, name, message, ...attachment }, { client: client2, path }) => ({
+          profile,
+          name,
+          message,
+          config: await resolveConfigId(client2, path, attachment)
+        })
+      }),
+      op({
+        verb: "update",
+        summary: "Replace a running agent's config",
+        fn: sdk_gen_exports.updateAgentConfig,
+        format: (response) => formatRecord()(response.agent_config),
+        path: zUpdateAgentConfigPath,
+        body: zConfigSourceAttachment.extend({
+          expected_current_config_id: zAgentConfigId.optional().describe("fail unless the agent still runs this config")
+        }),
+        transformBody: ({ expected_current_config_id, ...attachment }) => ({
+          ...renderConfigSource(attachment),
+          expected_current_config_id
+        })
       }),
       op({
         verb: "cancel",
@@ -7937,7 +8414,7 @@ var commandGroups = [
       flowOp({
         verb: "mcp-add",
         summary: "Create an OAuth secret and add an MCP server to an agent",
-        path: z11.object({
+        path: z14.object({
           orgID: zOrganizationId,
           projectID: zProjectId,
           agentID: zAgentId
@@ -8182,11 +8659,18 @@ var commandGroups = [
       }),
       op({
         verb: "create",
-        summary: "Create a machine",
-        fn: sdk_gen_exports.createMachine,
-        format: formatRecord(),
-        path: zCreateMachinePath,
-        body: zCreateMachineBody
+        summary: "Create a machine with a daemon token and show how to install omnarad",
+        fn: sdk_gen_exports.connectByoMachine,
+        format: formatMachineSetup,
+        path: zConnectByoMachinePath,
+        body: zConnectByoMachineBody
+      }),
+      flowOp({
+        verb: "create-local",
+        summary: "Create a machine and install omnarad on this machine",
+        path: zConnectByoMachinePath,
+        body: zMachineSetupBody,
+        run: runMachineCreateLocal
       }),
       op({
         verb: "update",
@@ -8399,7 +8883,7 @@ var commandGroups = [
       flowOp({
         verb: "mcp-oauth",
         summary: "Create a secret through an MCP server OAuth flow",
-        path: z11.object({ orgID: zOrganizationId }),
+        path: z14.object({ orgID: zOrganizationId }),
         body: zMcpOAuthBody,
         run: runMcpOAuth
       })
@@ -8472,7 +8956,28 @@ var commandGroups = [
         fn: sdk_gen_exports.createAgentProfile,
         format: formatRecord(),
         path: zCreateAgentProfilePath,
-        body: zCreateAgentProfileBody
+        body: zConfigAttachment.extend({ name: zResourceName }),
+        transformBody: async ({ name, ...attachment }, { client: client2, path }) => ({
+          name,
+          config: await resolveConfigId(client2, path, attachment)
+        })
+      }),
+      op({
+        verb: "update",
+        summary: "Point an agent profile at a new config",
+        fn: sdk_gen_exports.updateAgentProfile,
+        format: formatRecord(),
+        path: zUpdateAgentProfilePath,
+        body: zConfigAttachment.extend({
+          expected_current_config_id: zAgentConfigId.optional().describe("fail unless the profile still points at this config")
+        }),
+        transformBody: async ({ expected_current_config_id, ...attachment }, { client: client2, path }) => {
+          const expected = expected_current_config_id ?? await currentProfileConfigId(client2, path);
+          return {
+            config: await resolveConfigId(client2, path, attachment),
+            expected_current_config_id: expected
+          };
+        }
       }),
       op({
         verb: "rename",
@@ -8492,7 +8997,7 @@ var commandGroups = [
       flowOp({
         verb: "mcp-add",
         summary: "Create an OAuth secret and add an MCP server to an agent profile",
-        path: z11.object({
+        path: z14.object({
           orgID: zOrganizationId,
           projectID: zProjectId,
           agentProfileID: zAgentProfileId
@@ -8504,7 +9009,7 @@ var commandGroups = [
         verb: "slack",
         aliases: ["slack-setup"],
         summary: "Connect Slack to an agent profile through OAuth",
-        path: z11.object({
+        path: z14.object({
           orgID: zOrganizationId,
           projectID: zProjectId,
           agentProfileID: zAgentProfileId

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnara",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Command-line interface for Omnara: launch and manage agents, organizations, integrations, and MCP servers",
   "license": "Apache-2.0",
   "homepage": "https://omnara.com",