@intentic/sandbox-contract 1.272.0 → 1.273.0

package/src/schemas/hosts.ts

@@ -3,6 +3,12 @@ import { z } from "zod";
 // Manifest says which machines are intended; this says which actually hold a socket now. Nothing persists across a
 // daemon restart except the enrollment itself, so a closed laptop reads offline within a heartbeat.
 
+// Which WSL distro a Linux agent runs inside. Windows and every distro it hosts answer `hostname` with the same string
+// while being separate filesystems running separate agents, so this is what keeps a distro apart from the install
+// hosting it. `distro` is WSL's own name for it ("Arch", "Ubuntu-22.04"), empty when the distro won't say.
+export const WslEnvironmentSchema = z.object({ distro: z.string() });
+export type WslEnvironment = z.infer<typeof WslEnvironmentSchema>;
+
 // What a machine reports once at connect (`host.describe`), cached until it reconnects: the skill pack says how to
 // drive Windows, this says which Windows it is.
 export const HostFactsSchema = z.object({
@@ -18,8 +24,23 @@ export const HostFactsSchema = z.object({
     // Docker engine's size (WSL guest on Windows, Desktop VM on macOS, host on Linux); the ceiling a sandbox's share is
     // bounded by.
     engine: z.object({ memoryBytes: z.number(), cpus: z.number() }).optional(),
+    // OS hostname: the key that joins the doors of one physical machine. Reported by every agent that also reports
+    // `wsl`, so a hostname with no `wsl` beside it is a native install; absent from an agent older than both.
+    hostname: z.string().optional(),
+    // Present only inside a WSL distro.
+    wsl: WslEnvironmentSchema.optional(),
+    // Windows only: the distros `wsl -l -q` lists, the names `run_command`'s `in: "wsl:<name>"` accepts.
+    wslDistros: z.array(z.string()).optional(),
 });
 export type HostFacts = z.infer<typeof HostFactsSchema>;
+
+// One folder, two names. Windows sees a distro's files under a UNC share and a distro sees the Windows drives under
+// /mnt, so a path handed across the boundary is translated here rather than by hand at every call site.
+export const wslPathOf = (windowsPath: string): string | undefined => {
+    const drive = /^([A-Za-z]):[\\/](.*)$/.exec(windowsPath);
+    return drive === null ? undefined : `/mnt/${drive[1]?.toLowerCase()}/${(drive[2] ?? "").replaceAll("\\", "/")}`.replace(/\/$/, "");
+};
+export const windowsPathOf = (distro: string, linuxPath: string): string => `\\\\wsl.localhost\\${distro}${linuxPath.replaceAll("/", "\\")}`;
 export const HostSummarySchema = z.object({
     // The capability id, the machine's name, and the prefix of its tools (mcp__<id>__run_command).
     id: z.string(),

package/src/schemas/remote-refs.ts

@@ -0,0 +1,39 @@
+// What a git remote advertises right now: the versions an install form can pin to without anyone reading a sha off a
+// web page. Answered from `git ls-remote`, so nothing is cloned and nothing is written.
+import { z } from "zod";
+
+// POST so a private repository's token never rides a URL or an access log, the same reasoning as the marketplace read.
+export const RemoteRefsRequestSchema = z.object({
+    url: z.url().describe("The repository to ask. http(s) only: an ssh remote would stop on a host-key prompt nobody can answer."),
+    token: z
+        .string()
+        .min(1)
+        .optional()
+        .describe(
+            "A credential for a private one. Sent as a body rather than in the address, so it never lands in a log. A form editing a live connection has never been shown its token: it sends the VAULTED marker here and names the connection in `keeping`, so a private repository still answers without anyone retyping a key.",
+        ),
+    keeping: z
+        .string()
+        .min(1)
+        .optional()
+        .describe("Which connection a VAULTED token belongs to. Ignored when a real token is sent."),
+});
+
+export const RemoteRefSchema = z.object({
+    name: z.string().describe("The branch or tag as a person names it: `main`, `v1.4.0`."),
+    kind: z.enum(["branch", "tag"]),
+    sha: z
+        .string()
+        .regex(/^[0-9a-f]{40}$/)
+        .describe("The commit it points at. An annotated tag is peeled here, so this is always a commit, never a tag object."),
+});
+export type RemoteRef = z.infer<typeof RemoteRefSchema>;
+
+export const RemoteRefsSchema = z.object({
+    defaultBranch: z
+        .string()
+        .optional()
+        .describe("The branch the remote advertises as HEAD, the one to offer first. Absent when the remote advertises no symref."),
+    refs: z.array(RemoteRefSchema).describe("Every branch the remote advertises, then every tag. Which to offer first is the reader's question, not this one's."),
+});
+export type RemoteRefs = z.infer<typeof RemoteRefsSchema>;