@hasna/machines 0.0.18 → 0.0.20

package/dist/consumer.js

@@ -4212,6 +4212,7 @@ var machineSchema = exports_external.object({
   workspacePath: exports_external.string(),
   bunPath: exports_external.string().optional(),
   tags: exports_external.array(exports_external.string()).optional(),
+  metadata: exports_external.record(exports_external.unknown()).optional(),
   packages: exports_external.array(packageSchema).optional(),
   apps: exports_external.array(appSchema).optional(),
   files: exports_external.array(fileSchema).optional()
@@ -4310,6 +4311,40 @@ function getPackageVersion() {
 // src/topology.ts
 var MACHINES_CONSUMER_CONTRACT_VERSION = 1;
 var MACHINES_PACKAGE_NAME = "@hasna/machines";
+var MACHINES_CONSUMER_ENTRYPOINT = "@hasna/machines/consumer";
+var MACHINES_CONSUMER_CAPABILITIES = {
+  topology: true,
+  compatibility: true,
+  route_resolution: true,
+  cli_json_fallback: true,
+  workspace_path_mapping: true
+};
+var MACHINES_CONSUMER_CONTRACT = {
+  schema_version: MACHINES_CONSUMER_CONTRACT_VERSION,
+  package_name: MACHINES_PACKAGE_NAME,
+  entrypoint: MACHINES_CONSUMER_ENTRYPOINT,
+  capabilities: MACHINES_CONSUMER_CAPABILITIES,
+  envelopes: ["topology", "route", "workspace", "compatibility"],
+  stable_exports: [
+    "MACHINES_CONSUMER_CONTRACT",
+    "MACHINES_CONSUMER_CONTRACT_VERSION",
+    "MACHINES_CONSUMER_CAPABILITIES",
+    "MACHINES_PACKAGE_NAME",
+    "discoverMachineTopology",
+    "getLocalMachineTopology",
+    "resolveMachineRoute",
+    "resolveMachineWorkspace",
+    "checkMachineCompatibility",
+    "resolveMachineCommand",
+    "runMachineCommand",
+    "buildSshCommand",
+    "resolveSshTarget",
+    "getPackageVersion"
+  ]
+};
+function getMachinesConsumerCapabilities() {
+  return { ...MACHINES_CONSUMER_CAPABILITIES };
+}
 function normalizePlatform2(value = platform2()) {
   const normalized = value.toLowerCase();
   if (normalized === "darwin" || normalized === "macos")
@@ -4510,12 +4545,7 @@ function discoverMachineTopology(options = {}) {
       name: MACHINES_PACKAGE_NAME,
       version: getPackageVersion()
     },
-    capabilities: {
-      topology: true,
-      compatibility: true,
-      route_resolution: true,
-      cli_json_fallback: true
-    },
+    capabilities: getMachinesConsumerCapabilities(),
     generated_at: now.toISOString(),
     local_machine_id: localMachineId,
     local_hostname: hostname3(),
@@ -4639,6 +4669,215 @@ function resolveMachineRoute(machineId, options = {}) {
     warnings
   };
 }
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function metadataString(metadata, keys) {
+  for (const key of keys) {
+    const value = metadata[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  return null;
+}
+function metadataBoolean(metadata, keys) {
+  for (const key of keys) {
+    const value = metadata[key];
+    if (typeof value === "boolean")
+      return value;
+  }
+  return null;
+}
+function metadataStringArray(metadata, keys) {
+  for (const key of keys) {
+    const value = metadata[key];
+    if (Array.isArray(value))
+      return value.filter((entry) => typeof entry === "string");
+  }
+  return [];
+}
+function readMappedPath(input) {
+  for (const containerName of input.containers) {
+    const container = input.metadata[containerName];
+    if (!isRecord(container))
+      continue;
+    for (const key of input.keys) {
+      const value = container[key];
+      if (typeof value === "string" && value.trim())
+        return value.trim();
+      if (isRecord(value)) {
+        const path = metadataString(value, ["path", "root", "workspacePath", "workspace_path"]);
+        if (path)
+          return path;
+      }
+    }
+  }
+  return null;
+}
+function trimTrailingSlash(value) {
+  return value.replace(/\/+$/, "");
+}
+function joinPath(left, right) {
+  return `${trimTrailingSlash(left)}/${right.replace(/^\/+/, "")}`;
+}
+function inferRepoRoot(workspaceRoot, repoName) {
+  if (!workspaceRoot || !repoName)
+    return null;
+  const root = trimTrailingSlash(workspaceRoot);
+  if (root.endsWith(`/${repoName}`) || root === repoName)
+    return root;
+  if (root.endsWith("/workspace") || root.endsWith("/Workspace")) {
+    return joinPath(root, `hasna/opensource/${repoName}`);
+  }
+  return joinPath(root, repoName);
+}
+function projectPathFromMetadata(metadata, projectId, repoName) {
+  const keys = [projectId, repoName].filter((value) => Boolean(value));
+  return readMappedPath({
+    metadata,
+    containers: ["workspace_paths", "workspacePaths", "repo_paths", "repoPaths", "project_paths", "projectPaths", "projects"],
+    keys
+  });
+}
+function openFilesPathFromMetadata(metadata, projectId, repoName) {
+  const direct = metadataString(metadata, ["open_files_root", "openFilesRoot", "open_files_path", "openFilesPath"]);
+  if (direct)
+    return direct;
+  const keys = [projectId, repoName, "open-files", "open_files", "default"].filter((value) => Boolean(value));
+  return readMappedPath({
+    metadata,
+    containers: ["open_files_roots", "openFilesRoots", "open_files_paths", "openFilesPaths"],
+    keys
+  });
+}
+function trustStatus(machine) {
+  if (!machine)
+    return "unknown";
+  const explicit = metadataString(machine.metadata, ["trust_status", "trustStatus"]);
+  if (explicit === "trusted" || explicit === "untrusted" || explicit === "unknown")
+    return explicit;
+  const trusted = metadataBoolean(machine.metadata, ["trusted", "syncTrusted", "sync_trusted"]);
+  if (trusted === true)
+    return "trusted";
+  if (trusted === false)
+    return "untrusted";
+  if (machine.route_hints.some((hint) => hint.kind === "local"))
+    return "trusted";
+  if (machine.tags.includes("trusted"))
+    return "trusted";
+  return "unknown";
+}
+function authStatus(machine) {
+  if (!machine)
+    return "unknown";
+  const explicit = metadataString(machine.metadata, ["auth_status", "authStatus"]);
+  if (explicit === "authenticated" || explicit === "unauthenticated" || explicit === "unknown")
+    return explicit;
+  const authenticated = metadataBoolean(machine.metadata, ["authenticated", "sshAuthorized", "ssh_authorized"]);
+  if (authenticated === true)
+    return "authenticated";
+  if (authenticated === false)
+    return "unauthenticated";
+  if (machine.route_hints.some((hint) => hint.kind === "local"))
+    return "authenticated";
+  return "unknown";
+}
+function primaryMachine(machine, projectId, primaryMachineId) {
+  if (!machine)
+    return false;
+  if (primaryMachineId)
+    return machine.machine_id === primaryMachineId;
+  if (metadataBoolean(machine.metadata, ["primary", "primary_machine", "primaryMachine"]) === true)
+    return true;
+  const primaryProjects = metadataStringArray(machine.metadata, ["primary_projects", "primaryProjects"]);
+  if (primaryProjects.includes(projectId))
+    return true;
+  return machine.tags.includes("primary");
+}
+function metadataKeysForDiagnostics(metadata) {
+  return Object.keys(metadata).filter((key) => !/(secret|token|key|password|credential)/i.test(key)).sort();
+}
+function resolveMachineWorkspace(options) {
+  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 repoName = options.repoName ?? options.projectId;
+  const openFilesRepoName = options.openFilesRepoName ?? "open-files";
+  if (!machine) {
+    warnings.push(`machine_not_found:${options.machineId}`);
+    return {
+      schema_version: MACHINES_CONSUMER_CONTRACT_VERSION,
+      package: topology.package,
+      ok: false,
+      requested_machine_id: options.machineId,
+      machine_id: null,
+      generated_at: generatedAt,
+      project: { project_id: options.projectId, repo_name: repoName, canonical: Boolean(options.projectId) },
+      machine: { current: false, primary: false, trust_status: "unknown", auth_status: "unknown" },
+      paths: {
+        workspace_root: { path: null, source: "unresolved" },
+        project_root: { path: null, source: "unresolved" },
+        open_files_root: { path: null, source: "unresolved" }
+      },
+      evidence: {
+        topology: true,
+        matched_by: matchedBy,
+        manifest_declared: null,
+        metadata_keys: []
+      },
+      warnings
+    };
+  }
+  const metadata = machine.metadata;
+  const workspaceRootPath = options.workspaceRoot ?? machine.workspace_path;
+  const workspaceRootSource = options.workspaceRoot ? "argument" : machine.workspace_path ? "manifest" : "unresolved";
+  const metadataProjectRoot = projectPathFromMetadata(metadata, options.projectId, repoName);
+  const inferredProjectRoot = inferRepoRoot(workspaceRootPath, repoName);
+  const projectRootPath = options.projectRoot ?? metadataProjectRoot ?? inferredProjectRoot;
+  const projectRootSource = options.projectRoot ? "argument" : metadataProjectRoot ? "manifest_metadata" : inferredProjectRoot ? "inferred" : "unresolved";
+  const metadataOpenFilesRoot = openFilesPathFromMetadata(metadata, options.projectId, openFilesRepoName);
+  const inferredOpenFilesRoot = inferRepoRoot(workspaceRootPath, openFilesRepoName);
+  const openFilesRootPath = options.openFilesRoot ?? metadataOpenFilesRoot ?? inferredOpenFilesRoot;
+  const openFilesRootSource = options.openFilesRoot ? "argument" : metadataOpenFilesRoot ? "manifest_metadata" : inferredOpenFilesRoot ? "inferred" : "unresolved";
+  if (projectRootSource === "inferred")
+    warnings.push(`project_root_inferred:${options.projectId}`);
+  if (openFilesRootSource === "inferred")
+    warnings.push(`open_files_root_inferred:${options.projectId}`);
+  if (!projectRootPath)
+    warnings.push(`project_root_unresolved:${options.projectId}`);
+  return {
+    schema_version: MACHINES_CONSUMER_CONTRACT_VERSION,
+    package: topology.package,
+    ok: Boolean(projectRootPath),
+    requested_machine_id: options.machineId,
+    machine_id: machine.machine_id,
+    generated_at: generatedAt,
+    project: {
+      project_id: options.projectId,
+      repo_name: repoName,
+      canonical: Boolean(options.projectId && repoName)
+    },
+    machine: {
+      current: machine.machine_id === topology.local_machine_id,
+      primary: primaryMachine(machine, options.projectId, options.primaryMachineId),
+      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 }
+    },
+    evidence: {
+      topology: true,
+      matched_by: matchedBy,
+      manifest_declared: machine.manifest_declared,
+      metadata_keys: metadataKeysForDiagnostics(metadata)
+    },
+    warnings
+  };
+}
 function getLocalMachineTopology(options = {}) {
   const topology = discoverMachineTopology(options);
   return topology.machines.find((machine) => machine.machine_id === topology.local_machine_id) ?? {
@@ -4957,12 +5196,7 @@ function checkMachineCompatibility(options = {}) {
       name: MACHINES_PACKAGE_NAME,
       version: getPackageVersion()
     },
-    capabilities: {
-      topology: true,
-      compatibility: true,
-      route_resolution: true,
-      cli_json_fallback: true
-    },
+    capabilities: getMachinesConsumerCapabilities(),
     ok: summary.fail === 0,
     machine_id: machineId,
     source: checks[0]?.source ?? "local",
@@ -4974,13 +5208,18 @@ function checkMachineCompatibility(options = {}) {
 export {
   runMachineCommand,
   resolveSshTarget,
+  resolveMachineWorkspace,
   resolveMachineRoute,
   resolveMachineCommand,
   getPackageVersion,
+  getMachinesConsumerCapabilities,
   getLocalMachineTopology,
   discoverMachineTopology,
   checkMachineCompatibility,
   buildSshCommand,
   MACHINES_PACKAGE_NAME,
-  MACHINES_CONSUMER_CONTRACT_VERSION
+  MACHINES_CONSUMER_ENTRYPOINT,
+  MACHINES_CONSUMER_CONTRACT_VERSION,
+  MACHINES_CONSUMER_CONTRACT,
+  MACHINES_CONSUMER_CAPABILITIES
 };