@hasna/machines 0.0.23 → 0.0.25

package/dist/index.js

@@ -11060,6 +11060,7 @@ function writeManifest(manifest, path = getManifestPath()) {
     generatedAt: new Date().toISOString(),
     machines: normalizeMachines(manifest.machines)
   };
+  fleetSchema.parse(payload);
   writeFileSync(path, `${JSON.stringify(payload, null, 2)}
 `, "utf8");
   return path;
@@ -11112,29 +11113,78 @@ function getPackageVersion() {
 var MACHINES_CONSUMER_CONTRACT_VERSION = 1;
 var MACHINES_PACKAGE_NAME = "@hasna/machines";
 var MACHINES_CONSUMER_ENTRYPOINT = "@hasna/machines/consumer";
+var MACHINES_CONSUMER_SCHEMA_URI = "https://schemas.hasna.xyz/machines/consumer/v1/machines-consumer.schema.json";
+var MACHINES_CONSUMER_SCHEMA_ARTIFACT = "schemas/machines-consumer.schema.json";
+var DEFAULT_MACHINE_RESOLVER_TTL_MS = 24 * 60 * 60 * 1000;
 var MACHINES_CONSUMER_CAPABILITIES = {
   topology: true,
   compatibility: true,
   route_resolution: true,
   cli_json_fallback: true,
   workspace_path_mapping: true,
-  workspace_diagnostics: true
+  workspace_diagnostics: true,
+  schema_artifacts: true,
+  cacheability_metadata: true,
+  resolver_snapshots: true,
+  field_capability_descriptors: true
+};
+var MACHINES_CONSUMER_FIELD_CAPABILITIES = {
+  topology: {
+    machine_identity: true,
+    route_hints: true,
+    tailscale_status: true,
+    manifest_metadata: true
+  },
+  route: {
+    cacheability: true,
+    confidence: true,
+    resolver_evidence: true
+  },
+  workspace: {
+    cacheability: true,
+    path_mapping: true,
+    diagnostics: true,
+    repair_hints: true,
+    trust_auth: true
+  },
+  compatibility: {
+    commands: true,
+    packages: true,
+    workspaces: true
+  },
+  resolver_snapshot: {
+    cacheability: true,
+    redacted_provenance: true
+  }
 };
 var MACHINES_CONSUMER_CONTRACT = {
   schema_version: MACHINES_CONSUMER_CONTRACT_VERSION,
   package_name: MACHINES_PACKAGE_NAME,
   entrypoint: MACHINES_CONSUMER_ENTRYPOINT,
+  schema_uri: MACHINES_CONSUMER_SCHEMA_URI,
+  schema_artifact: MACHINES_CONSUMER_SCHEMA_ARTIFACT,
   capabilities: MACHINES_CONSUMER_CAPABILITIES,
-  envelopes: ["topology", "route", "workspace", "compatibility"],
+  field_capabilities: MACHINES_CONSUMER_FIELD_CAPABILITIES,
+  cacheability: {
+    default_ttl_ms: DEFAULT_MACHINE_RESOLVER_TTL_MS,
+    stale_requires_refresh: true
+  },
+  envelopes: ["topology", "route", "workspace", "compatibility", "resolver_snapshot"],
   stable_exports: [
     "MACHINES_CONSUMER_CONTRACT",
     "MACHINES_CONSUMER_CONTRACT_VERSION",
     "MACHINES_CONSUMER_CAPABILITIES",
+    "MACHINES_CONSUMER_FIELD_CAPABILITIES",
+    "MACHINES_CONSUMER_SCHEMA_BUNDLE",
+    "MACHINES_CONSUMER_SCHEMA_URI",
     "MACHINES_PACKAGE_NAME",
     "discoverMachineTopology",
     "getLocalMachineTopology",
     "resolveMachineRoute",
     "resolveMachineWorkspace",
+    "createMachineResolverSnapshot",
+    "getMachinesConsumerSchemaBundle",
+    "validateMachinesConsumerEnvelope",
     "checkMachineCompatibility",
     "resolveMachineCommand",
     "runMachineCommand",
@@ -11412,11 +11462,100 @@ function routeConfidence(input) {
     return "low";
   return "none";
 }
+function addMilliseconds(date, milliseconds) {
+  return new Date(date.getTime() + milliseconds).toISOString();
+}
+function routeAuthority(input) {
+  if (!input.machine)
+    return "unresolved";
+  if (input.matchedBy === "fallback")
+    return "fallback";
+  if (input.selectedHint?.kind === "local")
+    return "live_topology";
+  if (input.selectedHint?.kind === "tailscale" || input.machine.tailscale.online !== null)
+    return "live_topology";
+  if (input.machine.manifest_declared)
+    return "manifest";
+  return "open-machines";
+}
+function workspaceAuthority(paths) {
+  const sources = [paths.workspace_root.source, paths.project_root.source, paths.open_files_root.source];
+  if (sources.some((source) => source === "argument"))
+    return "argument";
+  if (sources.some((source) => source === "manifest_metadata"))
+    return "manifest_metadata";
+  if (sources.some((source) => source === "manifest"))
+    return "manifest";
+  if (sources.some((source) => source === "inferred"))
+    return "inferred";
+  if (sources.every((source) => source === "unresolved"))
+    return "unresolved";
+  return "open-machines";
+}
+function cacheability(input) {
+  const ttlMs = input.ttlMs === undefined ? DEFAULT_MACHINE_RESOLVER_TTL_MS : input.ttlMs;
+  const expiresAt = typeof ttlMs === "number" && ttlMs > 0 ? addMilliseconds(input.observedAt, ttlMs) : null;
+  const stale = expiresAt ? input.now.getTime() > new Date(expiresAt).getTime() : false;
+  const confidenceCacheable = input.confidence !== "none" && input.confidence !== "low";
+  const cacheable = input.ok && confidenceCacheable && !stale && input.authority !== "unresolved";
+  const reasons = [...input.reasons];
+  if (!input.ok)
+    reasons.push("resolver_not_ok");
+  if (!confidenceCacheable)
+    reasons.push(`low_confidence:${input.confidence}`);
+  if (stale)
+    reasons.push("stale");
+  if (input.authority === "unresolved")
+    reasons.push("unresolved_authority");
+  return {
+    observed_at: input.observedAt.toISOString(),
+    verified_at: input.ok ? input.now.toISOString() : null,
+    expires_at: expiresAt,
+    ttl_ms: typeof ttlMs === "number" && ttlMs > 0 ? ttlMs : null,
+    source_authority: input.authority,
+    confidence: input.confidence,
+    cacheable,
+    stale,
+    reasons: [...new Set(reasons)].sort()
+  };
+}
+function worstConfidence(values) {
+  const rank = {
+    exact: 0,
+    high: 1,
+    medium: 2,
+    low: 3,
+    none: 4
+  };
+  return [...values].sort((left, right) => rank[right] - rank[left])[0] ?? "none";
+}
+function mergeAuthorities(values) {
+  const filtered = values.filter((value) => value !== "unknown");
+  if (filtered.length === 0)
+    return "unknown";
+  const first = filtered[0];
+  return filtered.every((value) => value === first) ? first : "mixed";
+}
+function mergeCacheability(input) {
+  const confidence = worstConfidence(input.cacheabilities.map((entry) => entry.confidence));
+  const reasons = input.cacheabilities.flatMap((entry) => entry.reasons);
+  const ok = input.cacheabilities.every((entry) => entry.cacheable);
+  return cacheability({
+    ok,
+    observedAt: input.observedAt,
+    now: input.now,
+    ttlMs: input.ttlMs,
+    authority: mergeAuthorities(input.authorities),
+    confidence,
+    reasons
+  });
+}
 function resolveMachineRoute(machineId, options = {}) {
+  const now = options.now ?? new Date;
   const topology = options.topology ?? discoverMachineTopology(options);
   const warnings = [...topology.warnings];
   const { machine, matchedBy } = findRouteMachine(topology, machineId);
-  const generatedAt = (options.now ?? new Date).toISOString();
+  const generatedAt = now.toISOString();
   if (!machine) {
     warnings.push(`machine_not_found:${machineId}`);
     return {
@@ -11440,16 +11579,27 @@ function resolveMachineRoute(machineId, options = {}) {
         tailscale_online: null,
         selected_hint: null
       },
+      cacheability: cacheability({
+        ok: false,
+        observedAt: now,
+        now,
+        ttlMs: options.resolverTtlMs,
+        authority: "unresolved",
+        confidence: "none",
+        reasons: [`machine_not_found:${machineId}`]
+      }),
       warnings
     };
   }
   const selectedHint = selectRouteHint(machine.route_hints);
   const route = selectedHint?.kind ?? machine.ssh.route ?? "unknown";
   const local = route === "local" || machine.machine_id === topology.local_machine_id;
+  const confidence = routeConfidence({ machine, hint: selectedHint, matchedBy });
+  const ok = Boolean(selectedHint?.target);
   return {
     schema_version: MACHINES_CONSUMER_CONTRACT_VERSION,
     package: topology.package,
-    ok: Boolean(selectedHint?.target),
+    ok,
     machine_id: machine.machine_id,
     requested_machine_id: machineId,
     generated_at: generatedAt,
@@ -11457,7 +11607,7 @@ function resolveMachineRoute(machineId, options = {}) {
     source: route,
     target: selectedHint?.target ?? null,
     command_target: selectedHint?.target ?? null,
-    confidence: routeConfidence({ machine, hint: selectedHint, matchedBy }),
+    confidence,
     local,
     evidence: {
       topology: true,
@@ -11467,6 +11617,15 @@ function resolveMachineRoute(machineId, options = {}) {
       tailscale_online: machine.tailscale.online,
       selected_hint: selectedHint
     },
+    cacheability: cacheability({
+      ok,
+      observedAt: now,
+      now,
+      ttlMs: options.resolverTtlMs,
+      authority: routeAuthority({ machine, selectedHint, matchedBy }),
+      confidence,
+      reasons: selectedHint ? [] : ["route_target_unresolved"]
+    }),
     warnings
   };
 }
@@ -11763,10 +11922,11 @@ function metadataKeysForDiagnostics(metadata) {
   return Object.keys(metadata).filter((key) => !/(secret|token|key|password|credential)/i.test(key)).sort();
 }
 function resolveMachineWorkspace(options) {
+  const now = options.now ?? new Date;
   const topology = options.topology ?? discoverMachineTopology(options);
   const warnings = [...topology.warnings];
   const { machine, matchedBy } = findRouteMachine(topology, options.machineId);
-  const generatedAt = (options.now ?? new Date).toISOString();
+  const generatedAt = now.toISOString();
   const repoName = options.repoName ?? options.projectId;
   const openFilesRepoName = options.openFilesRepoName ?? "open-files";
   if (!machine) {
@@ -11793,6 +11953,15 @@ function resolveMachineWorkspace(options) {
         manifest_declared: null,
         metadata_keys: []
       },
+      cacheability: cacheability({
+        ok: false,
+        observedAt: now,
+        now,
+        ttlMs: options.resolverTtlMs,
+        authority: "unresolved",
+        confidence: "none",
+        reasons: [`machine_not_found:${options.machineId}`]
+      }),
       warnings
     };
     const diagnostics2 = workspaceDiagnostics({
@@ -11824,10 +11993,16 @@ function resolveMachineWorkspace(options) {
     warnings.push(`open_files_root_inferred:${options.projectId}`);
   if (!projectRootPath)
     warnings.push(`project_root_unresolved:${options.projectId}`);
+  const workspacePaths = {
+    workspace_root: { path: workspaceRootPath, source: workspaceRootSource },
+    project_root: { path: projectRootPath, source: projectRootSource },
+    open_files_root: { path: openFilesRootPath, source: openFilesRootSource }
+  };
+  const workspaceOk = Boolean(projectRootPath);
   const resolution = {
     schema_version: MACHINES_CONSUMER_CONTRACT_VERSION,
     package: topology.package,
-    ok: Boolean(projectRootPath),
+    ok: workspaceOk,
     requested_machine_id: options.machineId,
     machine_id: machine.machine_id,
     generated_at: generatedAt,
@@ -11842,11 +12017,7 @@ function resolveMachineWorkspace(options) {
       trust_status: trustStatus(machine),
       auth_status: authStatus(machine)
     },
-    paths: {
-      workspace_root: { path: workspaceRootPath, source: workspaceRootSource },
-      project_root: { path: projectRootPath, source: projectRootSource },
-      open_files_root: { path: openFilesRootPath, source: openFilesRootSource }
-    },
+    paths: workspacePaths,
     diagnostics: [],
     repair_hints: [],
     evidence: {
@@ -11855,6 +12026,15 @@ function resolveMachineWorkspace(options) {
       manifest_declared: machine.manifest_declared,
       metadata_keys: metadataKeysForDiagnostics(metadata)
     },
+    cacheability: cacheability({
+      ok: workspaceOk,
+      observedAt: now,
+      now,
+      ttlMs: options.resolverTtlMs,
+      authority: workspaceAuthority(workspacePaths),
+      confidence: workspaceOk ? "medium" : "none",
+      reasons: projectRootPath ? [] : [`project_root_unresolved:${options.projectId}`]
+    }),
     warnings
   };
   const diagnostics = workspaceDiagnostics({
@@ -11869,6 +12049,73 @@ function resolveMachineWorkspace(options) {
     repair_hints: diagnostics.repairHints
   };
 }
+function createMachineResolverSnapshot(options) {
+  const now = options.now ?? new Date;
+  const routeObservedAt = new Date(options.route.generated_at);
+  const workspaceObservedAt = options.workspace ? new Date(options.workspace.generated_at) : null;
+  const observedAt = new Date(Math.max(Number.isNaN(routeObservedAt.getTime()) ? 0 : routeObservedAt.getTime(), workspaceObservedAt && !Number.isNaN(workspaceObservedAt.getTime()) ? workspaceObservedAt.getTime() : 0));
+  const cacheabilities = [options.route.cacheability, options.workspace?.cacheability].filter((entry) => Boolean(entry));
+  const authorities = cacheabilities.map((entry) => entry.source_authority);
+  const warnings = [...new Set([
+    ...options.route.warnings,
+    ...options.workspace?.warnings ?? [],
+    ...cacheabilities.flatMap((entry) => entry.reasons)
+  ])].sort();
+  return {
+    schema_version: MACHINES_CONSUMER_CONTRACT_VERSION,
+    package: options.route.package,
+    generated_at: now.toISOString(),
+    requested_machine_id: options.route.requested_machine_id,
+    machine_id: options.route.machine_id ?? options.workspace?.machine_id ?? null,
+    route: {
+      ok: options.route.ok,
+      source: options.route.source,
+      route: options.route.route,
+      target: options.route.target,
+      command_target: options.route.command_target,
+      confidence: options.route.confidence,
+      local: options.route.local,
+      cacheability: options.route.cacheability
+    },
+    workspace: options.workspace ? {
+      ok: options.workspace.ok,
+      project: options.workspace.project,
+      machine: options.workspace.machine,
+      paths: options.workspace.paths,
+      diagnostics: options.workspace.diagnostics,
+      repair_hints: options.workspace.repair_hints,
+      cacheability: options.workspace.cacheability
+    } : null,
+    cacheability: mergeCacheability({
+      observedAt: observedAt.getTime() > 0 ? observedAt : now,
+      now,
+      ttlMs: options.resolverTtlMs,
+      authorities,
+      cacheabilities
+    }),
+    warnings,
+    provenance: {
+      route: {
+        schema_version: options.route.schema_version,
+        generated_at: options.route.generated_at,
+        evidence: {
+          matched_by: options.route.evidence.matched_by,
+          manifest_declared: options.route.evidence.manifest_declared,
+          heartbeat_status: options.route.evidence.heartbeat_status,
+          tailscale_online: options.route.evidence.tailscale_online,
+          selected_hint_kind: options.route.evidence.selected_hint?.kind ?? null
+        }
+      },
+      workspace: options.workspace ? {
+        schema_version: options.workspace.schema_version,
+        generated_at: options.workspace.generated_at,
+        metadata_keys: options.workspace.evidence.metadata_keys,
+        matched_by: options.workspace.evidence.matched_by,
+        manifest_declared: options.workspace.evidence.manifest_declared
+      } : null
+    }
+  };
+}
 function getLocalMachineTopology(options = {}) {
   const topology = discoverMachineTopology(options);
   return topology.machines.find((machine) => machine.machine_id === topology.local_machine_id) ?? {
@@ -12219,7 +12466,7 @@ function getAgentStatus(machineId = getLocalMachineId()) {
   }));
 }
 // src/commands/backup.ts
-import { homedir as homedir2 } from "os";
+import { homedir as homedir2, hostname as hostname5 } from "os";
 import { join as join3 } from "path";
 var MACHINES_BACKUP_BUCKET_ENV = "HASNA_MACHINES_S3_BUCKET";
 var MACHINES_BACKUP_BUCKET_FALLBACK_ENV = "MACHINES_S3_BUCKET";
@@ -12289,7 +12536,7 @@ function buildBackupPlan(bucket, prefix) {
     {
       id: "backup-upload",
       title: "Upload archive to S3",
-      command: `aws s3 cp ${quote(archivePath)} s3://${target.bucket}/${target.prefix}/$(hostname)-backup.tgz`,
+      command: `aws s3 cp ${quote(archivePath)} ${quote(`s3://${target.bucket}/${target.prefix}/${hostname5()}-backup.tgz`)}`,
       manager: "custom"
     }
   ];
@@ -12344,20 +12591,21 @@ function shellQuote5(value) {
 }
 function buildAppCommand(machine, app) {
   const packageName = getPackageName(app);
+  const quotedPackageName = shellQuote5(packageName);
   const manager = getAppManager(machine, app);
   if (manager === "custom") {
     return packageName;
   }
   if (machine.platform === "macos") {
     if (manager === "cask") {
-      return `brew install --cask ${packageName}`;
+      return `brew install --cask ${quotedPackageName}`;
     }
-    return `brew install ${packageName}`;
+    return `brew install ${quotedPackageName}`;
   }
   if (machine.platform === "windows") {
-    return `winget install ${packageName}`;
+    return `winget install ${quotedPackageName}`;
   }
-  return `sudo apt-get install -y ${packageName}`;
+  return `sudo apt-get install -y ${quotedPackageName}`;
 }
 function buildAppProbeCommand(machine, app) {
   const packageName = shellQuote5(getPackageName(app));
@@ -12643,9 +12891,10 @@ function manifestList() {
   return readManifest();
 }
 function manifestAdd(machine) {
+  const validatedMachine = machineSchema.parse(machine);
   const manifest = readManifest();
-  const nextMachines = manifest.machines.filter((entry) => entry.id !== machine.id);
-  nextMachines.push(machine);
+  const nextMachines = manifest.machines.filter((entry) => entry.id !== validatedMachine.id);
+  nextMachines.push(validatedMachine);
   const nextManifest = { ...manifest, machines: nextMachines };
   writeManifest(nextManifest);
   return nextManifest;
@@ -13495,6 +13744,7 @@ function runSelfTest() {
   };
 }
 // src/commands/setup.ts
+import { homedir as homedir4 } from "os";
 function quote3(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -13542,11 +13792,11 @@ function buildPackageSteps(machine) {
     const manager = pkg.manager || (machine.platform === "macos" ? "brew" : "apt");
     let command = pkg.name;
     if (manager === "bun") {
-      command = `bun install -g ${pkg.name}`;
+      command = `bun install -g ${quote3(pkg.name)}`;
     } else if (manager === "brew") {
-      command = `brew install ${pkg.name}`;
+      command = `brew install ${quote3(pkg.name)}`;
     } else if (manager === "apt") {
-      command = `sudo apt-get install -y ${pkg.name}`;
+      command = `sudo apt-get install -y ${quote3(pkg.name)}`;
     }
     return {
       id: `package-${index + 1}`,
@@ -13564,7 +13814,7 @@ function buildSetupPlan(machineId) {
   const target = selected || {
     id: currentMachineId,
     platform: "linux",
-    workspacePath: "~/workspace"
+    workspacePath: `${homedir4()}/workspace`
   };
   const steps = [...buildBaseSteps(target), ...buildPackageSteps(target)];
   return {
@@ -13608,8 +13858,58 @@ function runSetup(machineId, options = {}) {
   recordSetupRun(plan.machineId, "completed", summary);
   return summary;
 }
+// src/commands/screen.ts
+function shellQuote7(value) {
+  return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function splitTarget(target) {
+  const at = target.indexOf("@");
+  if (at === -1)
+    return [null, target];
+  return [target.slice(0, at), target.slice(at + 1)];
+}
+function resolveScreenTarget(machineId, options = {}) {
+  const resolved = resolveMachineRoute(machineId, options);
+  if (!resolved.ok || !resolved.target) {
+    throw new Error(`Machine route not found: ${machineId}`);
+  }
+  if (resolved.route === "unknown") {
+    throw new Error(`Machine route is not reachable for screen sharing: ${machineId}`);
+  }
+  let [user, host] = splitTarget(resolved.target);
+  if (!user) {
+    const topology = options.topology ?? discoverMachineTopology(options);
+    const entry = topology.machines.find((m) => m.machine_id === (resolved.machine_id ?? machineId));
+    user = entry?.user ?? null;
+  }
+  const url = user ? `vnc://${user}@${host}` : `vnc://${host}`;
+  return {
+    machineId: resolved.machine_id ?? machineId,
+    user,
+    host,
+    url,
+    route: resolved.route,
+    confidence: resolved.confidence,
+    warnings: resolved.warnings
+  };
+}
+function buildScreenCommand(machineId, options = {}) {
+  const resolved = resolveScreenTarget(machineId, options);
+  return `open ${resolved.url}`;
+}
+function buildScreenEnableRemoteCommand(user, vncPassword) {
+  const kickstart = "/System/Library/CoreServices/RemoteManagement/ARDAgent.app/Contents/Resources/kickstart";
+  const lines = [
+    `dseditgroup -o edit -a ${shellQuote7(user)} -t user com.apple.access_screensharing 2>/dev/null || true`,
+    "defaults write /Library/Preferences/com.apple.RemoteManagement AllowSRPForNetworkNodes -bool true",
+    `${kickstart} -configure -clientopts -setvnclegacy -vnclegacy yes -setvncpw -vncpw ${shellQuote7(vncPassword)}`,
+    `${kickstart} -activate -configure -access -on -users ${shellQuote7(user)} -privs -all -restart -agent -menu`
+  ];
+  return lines.join(" && ");
+}
 // src/commands/sync.ts
 import { existsSync as existsSync7, lstatSync, readFileSync as readFileSync5, symlinkSync, copyFileSync } from "fs";
+import { homedir as homedir5 } from "os";
 function quote4(value) {
   return `'${value.replace(/'/g, `'\\''`)}'`;
 }
@@ -13627,13 +13927,13 @@ function packageCheckCommand(machine, packageName, manager = machine.platform ==
 }
 function packageInstallCommand(machine, packageName, manager = machine.platform === "macos" ? "brew" : "apt") {
   if (manager === "bun") {
-    return `bun install -g ${packageName}`;
+    return `bun install -g ${quote4(packageName)}`;
   }
   if (manager === "brew") {
-    return `brew install ${packageName}`;
+    return `brew install ${quote4(packageName)}`;
   }
   if (manager === "apt") {
-    return `sudo apt-get install -y ${packageName}`;
+    return `sudo apt-get install -y ${quote4(packageName)}`;
   }
   return packageName;
 }
@@ -13686,7 +13986,7 @@ function buildSyncPlan(machineId) {
   const target = selected || {
     id: currentMachineId,
     platform: "linux",
-    workspacePath: "~/workspace"
+    workspacePath: `${homedir5()}/workspace`
   };
   const actions = [
     ...detectPackageActions(target),
@@ -14631,7 +14931,7 @@ var cidrv4 = /^((25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(25[0-5]
 var cidrv6 = /^(([0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}|::|([0-9a-fA-F]{1,4})?::([0-9a-fA-F]{1,4}:?){0,6})\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
 var base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0-9a-zA-Z+/]{3}=))?$/;
 var base64url = /^[A-Za-z0-9_-]*$/;
-var hostname5 = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
+var hostname6 = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
 var e164 = /^\+(?:[0-9]){6,14}[0-9]$/;
 var dateSource = `(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))`;
 var date = /* @__PURE__ */ new RegExp(`^${dateSource}$`);
@@ -15243,7 +15543,7 @@ var $ZodURL = /* @__PURE__ */ $constructor("$ZodURL", (inst, def) => {
             code: "invalid_format",
             format: "url",
             note: "Invalid hostname",
-            pattern: hostname5.source,
+            pattern: hostname6.source,
             input: payload.value,
             inst,
             continue: !def.abort
@@ -17232,7 +17532,7 @@ class JSONSchemaGenerator {
               if (val === undefined) {
                 if (this.unrepresentable === "throw") {
                   throw new Error("Literal `undefined` cannot be represented in JSON Schema");
-                } else {}
+                }
               } else if (typeof val === "bigint") {
                 if (this.unrepresentable === "throw") {
                   throw new Error("BigInt literals cannot be represented in JSON Schema");
@@ -23061,6 +23361,7 @@ export {
   runAppsInstall,
   resolveTables,
   resolveSshTarget,
+  resolveScreenTarget,
   resolveMachineWorkspace,
   resolveMachineRoute,
   resolveBackupTarget,
@@ -23125,6 +23426,7 @@ export {
   diffApps,
   detectCurrentMachineManifest,
   createMcpServer,
+  createMachineResolverSnapshot,
   countRuns,
   closeDb,
   checkMachineCompatibility,
@@ -23133,6 +23435,8 @@ export {
   buildSshCommand,
   buildSetupPlan,
   buildServer,
+  buildScreenEnableRemoteCommand,
+  buildScreenCommand,
   buildClaudeInstallPlan,
   buildCertPlan,
   buildBackupPlan,
@@ -23150,6 +23454,9 @@ export {
   MACHINES_STORAGE_FALLBACK_ENV,
   MACHINES_STORAGE_ENV,
   MACHINES_PACKAGE_NAME,
+  MACHINES_CONSUMER_SCHEMA_URI,
+  MACHINES_CONSUMER_SCHEMA_ARTIFACT,
+  MACHINES_CONSUMER_FIELD_CAPABILITIES,
   MACHINES_CONSUMER_ENTRYPOINT,
   MACHINES_CONSUMER_CONTRACT_VERSION,
   MACHINES_CONSUMER_CONTRACT,
@@ -23158,6 +23465,7 @@ export {
   MACHINES_BACKUP_PREFIX_ENV,
   MACHINES_BACKUP_BUCKET_FALLBACK_ENV,
   MACHINES_BACKUP_BUCKET_ENV,
+  DEFAULT_MACHINE_RESOLVER_TTL_MS,
   DEFAULT_BACKUP_PREFIX,
   CROSSREFS_KEY
 };

package/dist/manifests.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"manifests.d.ts","sourceRoot":"","sources":["../src/manifests.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAoBjE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcxB,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItB,CAAC;AAoBH,wBAAgB,kBAAkB,IAAI,aAAa,CAMlD;AAED,wBAAgB,YAAY,CAAC,IAAI,SAAoB,GAAG,aAAa,CAMpE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,SAAoB,GAAG,aAAa,CAExE;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,aAAa,EAAE,IAAI,SAAoB,GAAG,MAAM,CAUvF;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,SAAoB,GAAG,eAAe,GAAG,IAAI,CAEtG;AAED,wBAAgB,4BAA4B,IAAI,eAAe,CAiB9D"}
+{"version":3,"file":"manifests.d.ts","sourceRoot":"","sources":["../src/manifests.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAoBjE,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAcxB,CAAC;AAEH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAItB,CAAC;AAoBH,wBAAgB,kBAAkB,IAAI,aAAa,CAMlD;AAED,wBAAgB,YAAY,CAAC,IAAI,SAAoB,GAAG,aAAa,CAMpE;AAED,wBAAgB,gBAAgB,CAAC,IAAI,SAAoB,GAAG,aAAa,CAExE;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,aAAa,EAAE,IAAI,SAAoB,GAAG,MAAM,CAWvF;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,SAAoB,GAAG,eAAe,GAAG,IAAI,CAEtG;AAED,wBAAgB,4BAA4B,IAAI,eAAe,CAiB9D"}