@fungi.computer/computer 0.0.0-stage → 0.1.0

package/dist/apply-patch/main.rs

@@ -0,0 +1,320 @@
+//! Fungi's rooted, bounded host for the pinned upstream Codex patch engine.
+use codex_apply_patch::{
+    ApplyPatchError, ApplyPatchFileChange, ApplyPatchFileUpdateMode, ApplyPatchOptions, Hunk,
+    MaybeApplyPatchVerified, apply_patch_with_options, parse_patch, unified_diff_from_chunks,
+    verify_apply_patch_args_with_mode,
+};
+use codex_utils_absolute_path::AbsolutePathBuf;
+use codex_utils_path_uri::PathUri;
+use std::cmp::Reverse;
+use std::collections::HashSet;
+use std::fmt;
+use std::io::{self, Read};
+#[cfg(unix)]
+use std::os::unix::fs::MetadataExt;
+use std::path::{Component, Path, PathBuf};
+
+const MAX_BYTES: usize = 128 * 1024;
+const MAX_FILES: usize = 256;
+const MISMATCH_EXIT_CODE: i32 = 23;
+const FORMAT_EXIT_CODE: i32 = 24;
+
+fn expected_format(path: &Path) -> String {
+    format!(
+        "Expected patch format:\n*** Begin Patch\n*** Update File: {}\n@@\n-old line\n+new line\n*** End Patch\nUse @@ alone or @@ followed by an existing context line. Do not use unified-diff line numbers (such as @@ -1 +1 @@), --- or +++ file headers.\n",
+        preview(&path.to_string_lossy())
+    )
+}
+
+#[derive(Debug)]
+struct PatchFormatError(String);
+
+impl fmt::Display for PatchFormatError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(
+            f,
+            "{}\n{}",
+            self.0,
+            expected_format(Path::new("path/to/file.txt"))
+        )
+    }
+}
+
+impl std::error::Error for PatchFormatError {}
+
+#[derive(Debug)]
+struct PatchMismatch {
+    path: PathBuf,
+    expected: Vec<String>,
+    actual: Vec<(usize, String)>,
+}
+
+fn preview(line: &str) -> String {
+    let mut chars = line.chars();
+    let value: String = chars.by_ref().take(160).collect();
+    if chars.next().is_some() {
+        format!("{value}…")
+    } else {
+        value
+    }
+}
+
+impl fmt::Display for PatchMismatch {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        writeln!(
+            f,
+            "Patch hunk does not match {}.",
+            preview(&self.path.to_string_lossy())
+        )?;
+        writeln!(f, "Expected hunk:")?;
+        for line in self.expected.iter().take(5) {
+            writeln!(f, "  {}", preview(line))?;
+        }
+        if self.expected.len() > 5 {
+            writeln!(f, "  … {} more expected lines", self.expected.len() - 5)?;
+        }
+        writeln!(f, "Closest actual lines:")?;
+        for (number, line) in &self.actual {
+            writeln!(f, "  {number}: {}", preview(line))?;
+        }
+        writeln!(
+            f,
+            "Use the current lines above to correct this hunk and retry."
+        )?;
+        write!(f, "{}", expected_format(&self.path))
+    }
+}
+
+impl std::error::Error for PatchMismatch {}
+
+fn shared_edges(expected: &str, actual: &str) -> usize {
+    let prefix = expected
+        .chars()
+        .zip(actual.chars())
+        .take_while(|(left, right)| left == right)
+        .count();
+    let suffix = expected
+        .chars()
+        .rev()
+        .zip(actual.chars().rev())
+        .take_while(|(left, right)| left == right)
+        .count();
+    prefix + suffix
+}
+
+async fn first_mismatch(root: &Path, hunks: &[Hunk]) -> Option<PatchMismatch> {
+    for hunk in hunks {
+        let Hunk::UpdateFile { path, chunks, .. } = hunk else {
+            continue;
+        };
+        let target = admit(root, path).ok()?;
+        let source = std::fs::read_to_string(&target).ok()?;
+        let uri = PathUri::from_abs_path(&AbsolutePathBuf::try_from(target).ok()?);
+        let lines: Vec<&str> = source.lines().collect();
+        for (index, chunk) in chunks.iter().enumerate() {
+            // Let the engine identify the first failing chunk, including
+            // anchors, EOF and ordering. Never duplicate its matching rules.
+            if unified_diff_from_chunks(
+                &uri,
+                &chunks[..=index],
+                codex_exec_server::LOCAL_FS.as_ref(),
+                None,
+            )
+            .await
+            .is_ok()
+            {
+                continue;
+            }
+            let expected = if chunk.old_lines.is_empty() {
+                chunk.change_context.iter().cloned().collect()
+            } else {
+                chunk.old_lines.clone()
+            };
+            let nearest = (0..lines.len())
+                .max_by_key(|&start| {
+                    let score = expected
+                        .iter()
+                        .enumerate()
+                        .map(|(offset, old)| {
+                            lines
+                                .get(start + offset)
+                                .map_or(0, |actual| shared_edges(old, actual))
+                        })
+                        .sum::<usize>();
+                    (score, Reverse(start))
+                })
+                .unwrap_or(0);
+            let from = nearest.saturating_sub(2);
+            let to = (nearest + expected.len() + 2)
+                .min(lines.len())
+                .min(from + 7);
+            return Some(PatchMismatch {
+                path: path.clone(),
+                expected,
+                actual: (from..to)
+                    .map(|index| (index + 1, lines[index].to_owned()))
+                    .collect(),
+            });
+        }
+    }
+    None
+}
+
+fn admit(root: &Path, path: &Path) -> Result<PathBuf, Box<dyn std::error::Error>> {
+    let path = if path.is_absolute() {
+        path.to_path_buf()
+    } else {
+        root.join(path)
+    };
+    let relative = path
+        .strip_prefix(root)
+        .map_err(|_| "Patch path is outside the invocation root")?;
+    if relative.as_os_str().is_empty() {
+        return Err("Patch cannot replace the invocation root".into());
+    }
+    let mut current = root.to_path_buf();
+    for component in relative.components() {
+        match component {
+            Component::Normal(part) => current.push(part),
+            Component::CurDir => continue,
+            _ => return Err("Patch paths cannot contain parent traversal".into()),
+        }
+        match std::fs::symlink_metadata(&current) {
+            Ok(meta) => {
+                if meta.file_type().is_symlink() {
+                    return Err(
+                        format!("Patch cannot follow symlinks: {}", current.display()).into(),
+                    );
+                }
+                if !meta.is_dir() && !meta.is_file() {
+                    return Err("Patch requires regular files".into());
+                }
+                #[cfg(unix)]
+                if meta.is_file() && meta.nlink() > 1 {
+                    return Err(format!(
+                        "Patch cannot modify hard-linked file {}. Make a private copy in this folder (copy to a new file, then rename it over this path) and retry; files.edit can replace files under 128 KiB.",
+                        current.display()
+                    ).into());
+                }
+            }
+            Err(error) if error.kind() == io::ErrorKind::NotFound => {}
+            Err(error) => return Err(error.into()),
+        }
+    }
+    Ok(current)
+}
+
+async fn run() -> Result<(), Box<dyn std::error::Error>> {
+    let root = std::fs::canonicalize(std::env::current_dir()?)?;
+    let mut patch = String::new();
+    io::stdin()
+        .take((MAX_BYTES + 1) as u64)
+        .read_to_string(&mut patch)?;
+    if patch.len() > MAX_BYTES {
+        return Err("Patch exceeds the 128 KiB input bound".into());
+    }
+    let parsed = parse_patch(&patch).map_err(|error| PatchFormatError(error.to_string()))?;
+    if parsed.environment_id.is_some() || parsed.workdir.is_some() {
+        return Err("Patch cannot select another environment or working directory".into());
+    }
+    if parsed.hunks.is_empty() || parsed.hunks.len() > MAX_FILES {
+        return Err("Patch must affect between 1 and 256 files".into());
+    }
+    // Verification reads one pre-patch snapshot. Overlapping source/destination
+    // paths could otherwise invalidate its result-size checks during application.
+    let mut paths = HashSet::new();
+    let mut reserve = |path: &Path| -> Result<(), Box<dyn std::error::Error>> {
+        if !paths.insert(admit(&root, path)?) {
+            return Err("Patch operations have overlapping source or move paths".into());
+        }
+        Ok(())
+    };
+    for hunk in &parsed.hunks {
+        match hunk {
+            Hunk::AddFile { path, .. } | Hunk::DeleteFile { path } => reserve(path)?,
+            Hunk::UpdateFile {
+                path, move_path, ..
+            } => {
+                reserve(path)?;
+                if let Some(destination) = move_path {
+                    reserve(destination)?;
+                }
+            }
+        }
+    }
+    let cwd = PathUri::from_abs_path(&AbsolutePathBuf::try_from(PathBuf::from(&root))?);
+    let mode = ApplyPatchFileUpdateMode::PreserveLineEndings;
+    let diagnostic_hunks = parsed.hunks.clone();
+    let action = match verify_apply_patch_args_with_mode(
+        parsed,
+        &cwd,
+        mode,
+        codex_exec_server::LOCAL_FS.as_ref(),
+        None,
+    )
+    .await
+    {
+        MaybeApplyPatchVerified::Body(action) => action,
+        MaybeApplyPatchVerified::CorrectnessError(ApplyPatchError::ComputeReplacements(error)) => {
+            if let Some(mismatch) = first_mismatch(&root, &diagnostic_hunks).await {
+                return Err(Box::new(mismatch));
+            }
+            return Err(format!("Patch verification failed: {error}").into());
+        }
+        MaybeApplyPatchVerified::CorrectnessError(error) => {
+            return Err(format!("Patch verification failed: {error}").into());
+        }
+        MaybeApplyPatchVerified::ShellParseError(_) => {
+            return Err("Patch syntax error".into());
+        }
+        MaybeApplyPatchVerified::NotApplyPatch => {
+            return Err("Patch input was not an apply_patch call".into());
+        }
+    };
+    for change in action.changes().values() {
+        let changed_bytes = match change {
+            ApplyPatchFileChange::Add { content } | ApplyPatchFileChange::Delete { content } => {
+                content.len()
+            }
+            ApplyPatchFileChange::Update { unified_diff, .. } => unified_diff.len(),
+        };
+        if changed_bytes > MAX_BYTES {
+            return Err("Patch change exceeds the 128 KiB edit bound".into());
+        }
+    }
+    apply_patch_with_options(
+        &patch,
+        ApplyPatchOptions {
+            update_file_mode: mode,
+            follow_symlinks: false,
+        },
+        &cwd,
+        &mut io::stdout(),
+        &mut io::stderr(),
+        codex_exec_server::LOCAL_FS.as_ref(),
+        None,
+    )
+    .await
+    .map_err(|failure| {
+        let (error, delta) = failure.into_parts();
+        format!(
+            "{error}; {} file changes already applied (no rollback)",
+            delta.changes().len()
+        )
+    })?;
+    Ok(())
+}
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() {
+    if let Err(error) = run().await {
+        eprintln!("{error}");
+        std::process::exit(if error.is::<PatchMismatch>() {
+            MISMATCH_EXIT_CODE
+        } else if error.is::<PatchFormatError>() {
+            FORMAT_EXIT_CODE
+        } else {
+            1
+        });
+    }
+}

package/dist/apply-patch/notices.mjs

@@ -0,0 +1,44 @@
+import { readFile, readdir } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import { URL } from "node:url";
+
+const noticeName =
+  /^(licen[sc]es?|copying|copyright|notice|third.party.notices)([._-]|$)/i;
+
+export async function noticeFiles(directory) {
+  const result = [];
+  for (const entry of await readdir(directory, { withFileTypes: true })) {
+    if (!noticeName.test(entry.name)) continue;
+    const path = resolve(directory, entry.name);
+    if (entry.isFile()) result.push(path);
+    else if (entry.isDirectory()) {
+      for (const child of await readdir(path, { withFileTypes: true })) {
+        if (child.isFile()) result.push(resolve(path, child.name));
+      }
+    }
+  }
+  return result.sort();
+}
+
+// Cache the actual compiler closure's texts with its binary. Absolute Cargo
+// source paths cannot serve as packaging inputs after a cross-worktree cache hit.
+export async function nativeNotices(artifacts, sourceRoot) {
+  const packages = new Map();
+  for (const artifact of artifacts) {
+    const name = new URL(artifact.package_id).hash.slice(1);
+    if (!name) throw new Error("Native artifact has no Cargo package identity");
+    const directory = dirname(artifact.manifest_path);
+    const root = directory.startsWith(sourceRoot + "/")
+      ? sourceRoot
+      : directory;
+    packages.set(name, {
+      name,
+      texts: await Promise.all(
+        (await noticeFiles(root)).map((file) => readFile(file, "utf8")),
+      ),
+    });
+  }
+  return [...packages.values()].sort((left, right) =>
+    left.name.localeCompare(right.name),
+  );
+}

package/dist/apply-patch/pin.mjs

@@ -0,0 +1,8 @@
+/** The shared artifact identity; this directory is a native Turbo input. */
+export const codexPatchPin = Object.freeze({
+  version: "rust-v0.154.0",
+  sourceSha256:
+    "1c4cdc3b87ba290b5d110425b4f6ff21663e236580bc760d1e149bd2d9f9519f",
+  /** The Rust toolchain every builder (host, container, image stage) uses. */
+  rustToolchain: "1.98.1",
+});

package/dist/apply-patch/toolchain.mjs

@@ -0,0 +1,39 @@
+// Selects the pinned Rust toolchain's `cargo` for the native patch build.
+//
+// Every builder (a native host, the release containers and the Computer
+// image's builder stage) installs Rust through rustup. A non-rustup `cargo`
+// earlier on `PATH` (for example Homebrew's) rejects the `+toolchain`
+// directive, so the build asks rustup's ordinary interface for the pinned
+// toolchain's `cargo` explicitly.
+import { spawnSync } from "node:child_process";
+
+/**
+ * Builds the `{ command, args }` cargo invocation for the pinned toolchain.
+ *
+ * @param {{ toolchain: string, cargoArgs: string[] }} options
+ */
+export function selectCargoInvocation({ toolchain, cargoArgs }) {
+  return { command: "rustup", args: ["run", toolchain, "cargo", ...cargoArgs] };
+}
+
+/**
+ * Confirms rustup and the pinned toolchain are available before starting the
+ * real build, so a missing prerequisite fails with one actionable message
+ * naming the fix instead of an opaque nested build error.
+ *
+ * @param {{ toolchain: string }} options
+ */
+export function ensureNativeHostToolchain({ toolchain }) {
+  const probe = spawnSync("rustup", ["run", toolchain, "cargo", "--version"], {
+    encoding: "utf8",
+  });
+  if (probe.error?.code === "ENOENT")
+    throw new Error(
+      `Cordyceps' native patch build needs rustup with the Rust ${toolchain} toolchain. Install rustup from https://rustup.rs, then run \`rustup toolchain install ${toolchain}\`.`,
+    );
+  if (probe.error) throw probe.error;
+  if (probe.status !== 0)
+    throw new Error(
+      `Cordyceps' native patch build needs the Rust ${toolchain} toolchain through rustup. Run \`rustup toolchain install ${toolchain}\`. rustup reported: ${probe.stderr.trim()}`,
+    );
+}

package/dist/computer-backends.d.ts

@@ -0,0 +1,94 @@
+import * as z from "zod";
+/** A backend the platform runs: a Cloudflare container or an on-box VM. */
+export declare const hostedBackingSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"platform-container">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"on-box-vm">;
+    hostId: z.ZodLazy<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export type HostedBacking = z.infer<typeof hostedBackingSchema>;
+/** A member's machine, attached with a device key that never leaves it. */
+export declare const localBackendSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"local">;
+    deviceId: z.ZodString;
+    publicKey: z.ZodBase64;
+    hostLabel: z.ZodLazy<z.ZodString>;
+    folderLabel: z.ZodLazy<z.ZodString>;
+}, z.core.$strict>;
+export type LocalBackend = z.infer<typeof localBackendSchema>;
+export declare const attachedBackendSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"platform-container">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"on-box-vm">;
+    hostId: z.ZodLazy<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"local">;
+    deviceId: z.ZodString;
+    publicKey: z.ZodBase64;
+    hostLabel: z.ZodLazy<z.ZodString>;
+    folderLabel: z.ZodLazy<z.ZodString>;
+}, z.core.$strict>], "kind">;
+export type AttachedBackend = z.infer<typeof attachedBackendSchema>;
+/** The stable Workspace backend id: its sync cursor is keyed by it. */
+export declare function attachedBackendId(backend: AttachedBackend): string;
+/** One Computer's attached backends, in attach order; ids are unique. */
+export declare const attachedBackendsSchema: z.ZodLazy<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"platform-container">;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"on-box-vm">;
+    hostId: z.ZodLazy<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"local">;
+    deviceId: z.ZodString;
+    publicKey: z.ZodBase64;
+    hostLabel: z.ZodLazy<z.ZodString>;
+    folderLabel: z.ZodLazy<z.ZodString>;
+}, z.core.$strict>], "kind">>>;
+export declare const attachedBackendIdSchema: z.ZodLazy<z.ZodString>;
+export type AttachedBackendStatus = "ready" | "online" | "offline";
+/** What a Computer reports about one attached backend. */
+export type AttachedBackendView = Readonly<{
+    id: string;
+    kind: AttachedBackend["kind"];
+    status: AttachedBackendStatus;
+    hostId?: string;
+    hostLabel?: string;
+    folderLabel?: string;
+}>;
+export declare function describeAttachedBackend(backend: AttachedBackend, online: boolean): AttachedBackendView;
+/** What a command needs from its backend. */
+export type BackendNeed = 
+/** A shell over the Computer's files: any attached backend. */
+"exec"
+/** Terminal, processes or ports: a platform-run backend only. */
+ | "hosted";
+export type BackendRoute = Readonly<{
+    kind: "routed";
+    id: string;
+    backend: AttachedBackend;
+}>
+/** The named backend is not attached, cannot serve the need, or is offline. */
+ | Readonly<{
+    kind: "backend_unavailable";
+    id: string;
+}>
+/** No attached backend can serve the command now. */
+ | Readonly<{
+    kind: "no_backend";
+}>;
+/**
+ * The single routing decision. An explicit id selects exactly that backend
+ * and never falls back. Otherwise the default order is online local backends,
+ * then on-box VMs, then the platform container, each kind in attach order.
+ * Hosted backends start on demand, so only a local backend can be offline.
+ */
+export declare function routeComputerBackend(backends: readonly AttachedBackend[], online: (id: string) => boolean, request: Readonly<{
+    backend?: string | undefined;
+    need: BackendNeed;
+}>): BackendRoute;
+/** One container runtime a hosted backend started: the Computer-hours unit. */
+export type ContainerRuntimeStart = Readonly<{
+    runtimeId: string;
+    backing: HostedBacking;
+    startedAt: number;
+}>;

package/dist/computer-backends.js

@@ -0,0 +1,103 @@
+import * as z from "zod";
+/**
+ * A Computer is its SQLite Workspace. Execution backends are optional and
+ * plural: this module owns their vocabulary, their stable Workspace backend
+ * ids, and the one routing decision that picks a backend for a command.
+ *
+ * Every shape here is secret-free. A hosted backing names a registered host
+ * id at most; a local backend carries its device's public key and two display
+ * labels, never a path on the member's machine.
+ */
+const hostIdSchema = z.lazy(() => z.string().regex(/^[a-z0-9][a-z0-9-]{0,62}$/));
+const labelSchema = z.lazy(() => z.string().trim().min(1).max(256));
+/** A backend the platform runs: a Cloudflare container or an on-box VM. */
+export const hostedBackingSchema = z.discriminatedUnion("kind", [
+    z.strictObject({ kind: z.literal("platform-container") }),
+    z.strictObject({ kind: z.literal("on-box-vm"), hostId: hostIdSchema }),
+]);
+/** A member's machine, attached with a device key that never leaves it. */
+export const localBackendSchema = z.strictObject({
+    kind: z.literal("local"),
+    deviceId: z.string().regex(/^[a-z2-7]{16}$/),
+    /** Raw 32-byte Ed25519 public key, base64. */
+    publicKey: z.base64().length(44),
+    hostLabel: labelSchema,
+    folderLabel: labelSchema,
+});
+export const attachedBackendSchema = z.discriminatedUnion("kind", [
+    ...hostedBackingSchema.options,
+    localBackendSchema,
+]);
+/** The stable Workspace backend id: its sync cursor is keyed by it. */
+export function attachedBackendId(backend) {
+    switch (backend.kind) {
+        case "platform-container":
+            return "container";
+        case "on-box-vm":
+            return `vm-${backend.hostId}`;
+        case "local":
+            return `local-${backend.deviceId}`;
+    }
+}
+/** One Computer's attached backends, in attach order; ids are unique. */
+export const attachedBackendsSchema = z.lazy(() => z
+    .array(attachedBackendSchema)
+    .max(16)
+    .refine((backends) => new Set(backends.map(attachedBackendId)).size === backends.length, "attached backend ids must be unique"));
+export const attachedBackendIdSchema = z.lazy(() => z
+    .string()
+    .regex(/^(container|vm-[a-z0-9][a-z0-9-]{0,62}|local-[a-z2-7]{16})$/));
+export function describeAttachedBackend(backend, online) {
+    const id = attachedBackendId(backend);
+    switch (backend.kind) {
+        case "platform-container":
+            return { id, kind: backend.kind, status: "ready" };
+        case "on-box-vm":
+            return {
+                id,
+                kind: backend.kind,
+                status: "ready",
+                hostId: backend.hostId,
+            };
+        case "local":
+            return {
+                id,
+                kind: backend.kind,
+                status: online ? "online" : "offline",
+                hostLabel: backend.hostLabel,
+                folderLabel: backend.folderLabel,
+            };
+    }
+}
+const defaultRank = {
+    local: 0,
+    "on-box-vm": 1,
+    "platform-container": 2,
+};
+function serves(backend, need) {
+    return need === "exec" || backend.kind !== "local";
+}
+/**
+ * The single routing decision. An explicit id selects exactly that backend
+ * and never falls back. Otherwise the default order is online local backends,
+ * then on-box VMs, then the platform container, each kind in attach order.
+ * Hosted backends start on demand, so only a local backend can be offline.
+ */
+export function routeComputerBackend(backends, online, request) {
+    const available = (backend) => serves(backend, request.need) &&
+        (backend.kind !== "local" || online(attachedBackendId(backend)));
+    if (request.backend !== undefined) {
+        const backend = backends.find((candidate) => attachedBackendId(candidate) === request.backend);
+        return backend !== undefined && available(backend)
+            ? { kind: "routed", id: request.backend, backend }
+            : { kind: "backend_unavailable", id: request.backend };
+    }
+    const chosen = backends
+        .map((backend, index) => ({ backend, index }))
+        .filter(({ backend }) => available(backend))
+        .sort((left, right) => defaultRank[left.backend.kind] - defaultRank[right.backend.kind] ||
+        left.index - right.index)[0]?.backend;
+    return chosen === undefined
+        ? { kind: "no_backend" }
+        : { kind: "routed", id: attachedBackendId(chosen), backend: chosen };
+}