@fungi.computer/truffle 0.0.0-stage → 0.1.1

package/dist/private-local-computer-processes.d.ts

@@ -0,0 +1,199 @@
+import { z } from "zod";
+declare const processSchema: z.ZodObject<{
+    id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string>>;
+    command: z.ZodString;
+    cwd: z.ZodString;
+    state: z.ZodEnum<{
+        running: "running";
+        exited: "exited";
+    }>;
+    exitCode: z.ZodNullable<z.ZodNumber>;
+    signal: z.ZodNullable<z.ZodString>;
+    startedAt: z.ZodNumber;
+    endedAt: z.ZodNullable<z.ZodNumber>;
+    logPath: z.ZodString;
+    logBytes: z.ZodNumber;
+    logStartOffset: z.ZodNumber;
+    logTruncated: z.ZodBoolean;
+}, z.core.$strict>;
+/** One background process as the agent sees it. */
+export type PrivateLocalProcess = z.output<typeof processSchema>;
+declare const readOutput: z.ZodObject<{
+    process: z.ZodObject<{
+        id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string>>;
+        command: z.ZodString;
+        cwd: z.ZodString;
+        state: z.ZodEnum<{
+            running: "running";
+            exited: "exited";
+        }>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        signal: z.ZodNullable<z.ZodString>;
+        startedAt: z.ZodNumber;
+        endedAt: z.ZodNullable<z.ZodNumber>;
+        logPath: z.ZodString;
+        logBytes: z.ZodNumber;
+        logStartOffset: z.ZodNumber;
+        logTruncated: z.ZodBoolean;
+    }, z.core.$strict>;
+    offset: z.ZodNumber;
+    nextOffset: z.ZodNumber;
+    text: z.ZodString;
+    complete: z.ZodBoolean;
+}, z.core.$strict>;
+declare const waitOutput: z.ZodObject<{
+    process: z.ZodObject<{
+        id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string>>;
+        command: z.ZodString;
+        cwd: z.ZodString;
+        state: z.ZodEnum<{
+            running: "running";
+            exited: "exited";
+        }>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        signal: z.ZodNullable<z.ZodString>;
+        startedAt: z.ZodNumber;
+        endedAt: z.ZodNullable<z.ZodNumber>;
+        logPath: z.ZodString;
+        logBytes: z.ZodNumber;
+        logStartOffset: z.ZodNumber;
+        logTruncated: z.ZodBoolean;
+    }, z.core.$strict>;
+    timedOut: z.ZodBoolean;
+}, z.core.$strict>;
+declare const killOutput: z.ZodObject<{
+    process: z.ZodObject<{
+        id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string>>;
+        command: z.ZodString;
+        cwd: z.ZodString;
+        state: z.ZodEnum<{
+            running: "running";
+            exited: "exited";
+        }>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        signal: z.ZodNullable<z.ZodString>;
+        startedAt: z.ZodNumber;
+        endedAt: z.ZodNullable<z.ZodNumber>;
+        logPath: z.ZodString;
+        logBytes: z.ZodNumber;
+        logStartOffset: z.ZodNumber;
+        logTruncated: z.ZodBoolean;
+    }, z.core.$strict>;
+    signalled: z.ZodBoolean;
+}, z.core.$strict>;
+/**
+ * One background `start` request, narrowed to what actually spawns a
+ * process: a shell command line, or a direct executable with argv. Either
+ * form may carry finite stdin, delivered once and closed before `start`
+ * returns a process id.
+ */
+export type PrivateLocalProcessCommandSpec = Readonly<{
+    readonly kind: "shell";
+    readonly command: string;
+    readonly stdin?: string;
+} | {
+    readonly kind: "direct";
+    readonly executable: string;
+    readonly args: readonly string[];
+    readonly stdin?: string;
+}>;
+/** One Session's (or invocation's) view of the host's background processes. */
+export type PrivateLocalProcessScope = Readonly<{
+    start: (spec: PrivateLocalProcessCommandSpec, cwd: string, executionPath: string) => Promise<PrivateLocalProcess>;
+    status: (id: string) => PrivateLocalProcess;
+    list: () => readonly PrivateLocalProcess[];
+    read: (id: string, offset: number, maxBytes: number) => Promise<z.output<typeof readOutput>>;
+    wait: (id: string, timeoutMs: number, signal: AbortSignal) => Promise<z.output<typeof waitOutput>>;
+    kill: (id: string) => Promise<z.output<typeof killOutput>>;
+}>;
+/** The host's one background-process owner. */
+export type PrivateLocalComputerProcesses = Readonly<{
+    scope: (key: string) => PrivateLocalProcessScope;
+    /** Stop every process of one scope and remove its logs (Session ended). */
+    disposeScope: (key: string) => Promise<void>;
+    /** Stop every process, remove every log, and refuse new starts. */
+    close: () => Promise<void>;
+}>;
+/** Open the background-process owner for one invocation root. */
+export declare function createPrivateLocalComputerProcesses(root: string): PrivateLocalComputerProcesses;
+/**
+ * Background operations share the Computer's one shell/exec surface; a
+ * plain (not discriminated) union, since `start`'s shell and direct branches
+ * share the `operation:"start"` literal that `discriminatedUnion` requires
+ * to be unique per branch. Both/neither of `command`/`executable` are still
+ * refused, by the strict objects themselves.
+ */
+export declare const backgroundExecInput: z.ZodUnion<readonly [z.ZodObject<{
+    operation: z.ZodLiteral<"start">;
+    command: z.ZodString;
+    stdin: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"start">;
+    executable: z.ZodString;
+    args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    stdin: z.ZodOptional<z.ZodString>;
+    cwd: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string>>;
+    maxBytes: z.ZodDefault<z.ZodNumber>;
+    operation: z.ZodLiteral<"poll">;
+    offset: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string>>;
+    timeoutMs: z.ZodDefault<z.ZodNumber>;
+    operation: z.ZodLiteral<"wait">;
+    offset: z.ZodOptional<z.ZodNumber>;
+    maxBytes: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string>>;
+    operation: z.ZodLiteral<"kill">;
+}, z.core.$strict>, z.ZodObject<{
+    operation: z.ZodLiteral<"list">;
+}, z.core.$strict>]>;
+export declare const backgroundExecOutput: z.ZodUnion<readonly [z.ZodObject<{
+    process: z.ZodObject<{
+        id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string>>;
+        command: z.ZodString;
+        cwd: z.ZodString;
+        state: z.ZodEnum<{
+            running: "running";
+            exited: "exited";
+        }>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        signal: z.ZodNullable<z.ZodString>;
+        startedAt: z.ZodNumber;
+        endedAt: z.ZodNullable<z.ZodNumber>;
+        logPath: z.ZodString;
+        logBytes: z.ZodNumber;
+        logStartOffset: z.ZodNumber;
+        logTruncated: z.ZodBoolean;
+    }, z.core.$strict>;
+    offset: z.ZodNumber;
+    nextOffset: z.ZodNumber;
+    text: z.ZodString;
+    complete: z.ZodBoolean;
+    timedOut: z.ZodBoolean;
+    signalled: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>, z.ZodObject<{
+    processes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString & z.ZodType<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string, z.core.$ZodTypeInternals<import("@fungi.computer/cairn").CairnId<"local-computer-process", "process", 1>, string>>;
+        command: z.ZodString;
+        cwd: z.ZodString;
+        state: z.ZodEnum<{
+            running: "running";
+            exited: "exited";
+        }>;
+        exitCode: z.ZodNullable<z.ZodNumber>;
+        signal: z.ZodNullable<z.ZodString>;
+        startedAt: z.ZodNumber;
+        endedAt: z.ZodNullable<z.ZodNumber>;
+        logPath: z.ZodString;
+        logBytes: z.ZodNumber;
+        logStartOffset: z.ZodNumber;
+        logTruncated: z.ZodBoolean;
+    }, z.core.$strict>>;
+}, z.core.$strict>]>;
+/** Reuse Session ownership and logs; a wait deadline never cancels the command. */
+export declare function callBackgroundExec(scope: PrivateLocalProcessScope, request: z.output<typeof backgroundExecInput>, resolveCwd: (requested: string | undefined) => Promise<string>, executionPath: string, signal: AbortSignal): Promise<z.output<typeof backgroundExecOutput>>;
+export {};