@fungi.computer/truffle 0.0.0-stage → 0.2.0

package/dist/private-local-service-process.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/private-local-service-process.js

@@ -0,0 +1,8 @@
+import { serviceDirectory } from "./private-local-service-discovery.js";
+import { runPrivateLocalService } from "./private-local-service-listener.js";
+import { capturePrivateLocalConfigRoot } from "./private-local-config-root.js";
+const directory = process.argv[2];
+if (!directory)
+    throw new Error("Local service requires its private directory");
+const root = capturePrivateLocalConfigRoot();
+await runPrivateLocalService(await serviceDirectory(directory), undefined, undefined, undefined, undefined, undefined, root);

package/dist/private-local-service-termination.d.ts

@@ -0,0 +1,7 @@
+import { type ServiceLeaseOwner } from "./private-local-service-lease.js";
+/**
+ * SIGTERM the service, wait up to five seconds for it to exit, then SIGKILL.
+ * A hung owner drain can no longer leave a discoverable but unusable service.
+ * Each signal first checks that the PID still names the recorded process.
+ */
+export declare function terminatePrivateLocalService(directory: string, service: ServiceLeaseOwner): Promise<"stopped" | "killed">;

package/dist/private-local-service-termination.js

@@ -0,0 +1,67 @@
+import { setTimeout as delay } from "node:timers/promises";
+import { readProcessStart } from "./private-local-process-identity.js";
+import { readServiceLeaseOwner, } from "./private-local-service-lease.js";
+/** How long a SIGTERM'd service may drain its owners before it is killed. */
+const terminationGraceMs = 5_000;
+const terminationPollMs = 50;
+/**
+ * Whether `service` is still the process running under its PID. A PID whose
+ * start differs is refused. A separate read and signal still has a race window.
+ */
+async function isServiceProcess(service) {
+    const current = await readProcessStart(service.pid);
+    if (current.kind === "unverifiable")
+        throw new Error(`Fungi cannot verify the service process ${String(service.pid)} with sub-second precision on ${process.platform}, so it refuses to signal it. Close that service manually, then reopen Fungi.`);
+    return current.kind === "running" && current.start === service.startedAt;
+}
+/** Signal `pid`; false when it has already exited. */
+function signalService(pid, signal) {
+    try {
+        process.kill(pid, signal);
+        return true;
+    }
+    catch (cause) {
+        if (cause instanceof Error && "code" in cause && cause.code === "ESRCH")
+            return false;
+        if (cause instanceof Error && "code" in cause && cause.code === "EPERM")
+            throw new Error(`The Fungi service process ${String(pid)} belongs to another user, so fungi stop may not signal it. Stop it as that user (for example \`sudo kill ${String(pid)}\`), then retry.`, { cause });
+        throw cause;
+    }
+}
+/** Signal `service` only while its PID still names that same process. */
+async function signalIfStillRunning(directory, service, signal) {
+    const owner = await readServiceLeaseOwner(directory);
+    if (owner?.pid !== service.pid || owner.startedAt !== service.startedAt)
+        return false;
+    return (await isServiceProcess(owner)) && signalService(owner.pid, signal);
+}
+async function exitedWithin(service, ms) {
+    const deadline = Date.now() + ms;
+    for (;;) {
+        if (!(await isServiceProcess(service)))
+            return true;
+        if (Date.now() >= deadline)
+            return false;
+        await delay(terminationPollMs);
+    }
+}
+/**
+ * SIGTERM the service, wait up to five seconds for it to exit, then SIGKILL.
+ * A hung owner drain can no longer leave a discoverable but unusable service.
+ * Each signal first checks that the PID still names the recorded process.
+ */
+export async function terminatePrivateLocalService(directory, service) {
+    // A listener run inside its caller (tests, embedded hosts) would otherwise
+    // be SIGKILLed together with that caller.
+    if (service.pid === process.pid)
+        throw new Error("The Fungi service runs inside this process; stop it from within instead of with fungi stop.");
+    if (!(await signalIfStillRunning(directory, service, "SIGTERM")))
+        return "stopped";
+    if (await exitedWithin(service, terminationGraceMs))
+        return "stopped";
+    if (!(await signalIfStillRunning(directory, service, "SIGKILL")))
+        return "stopped";
+    if (await exitedWithin(service, terminationGraceMs))
+        return "killed";
+    throw new Error(`Local service process ${String(service.pid)} is still running after SIGKILL`);
+}

package/dist/private-local-service.d.ts

@@ -0,0 +1,46 @@
+export { LocalSandboxUnavailable } from "./private-local-containment.js";
+export type { StopAllResult } from "./private-local-stop-all.js";
+export { LocalAgentSelectionAmbiguous, LocalSessionPathConflict, } from "./private-local-service-owner.js";
+export { AgentArchiveRefused } from "@fungi.computer/shiitake/agent-control";
+export { readInstalledLocalClientBuildId } from "./private-local-client-version.js";
+export { privateLocalServiceVersion } from "./private-local-service-discovery.js";
+import type { ShiitakeEventSourceConstructor } from "@fungi.computer/shiitake/client";
+import type { PrivateLocalServiceManager } from "./private-local-service-contract.js";
+export { LocalStoreSchemaError } from "./private-local-session-discovery.js";
+export type { PrivateLocalServiceStatus, PrivateLocalServiceStopResult, PrivateLocalServiceSelection, PrivateLocalSessionCreation, PrivateLocalServiceConnection, PrivateLocalServiceRebind, PrivateLocalServiceManager, PrivateLocalServiceRequestOptions, PrivateLocalDiscoveryOptions, PrivateLocalArchiveRequest, PrivateLocalAgentChoice, PrivateLocalSessionChoice, PrivateLocalSessionDiscovery, PrivateLocalSessionInspection, PrivateLocalSessionProblem, } from "./private-local-service-contract.js";
+export type { PrivateLocalModelChoice } from "./local-models.js";
+export type { ServiceDiagnosticsStatus, ServiceDiagnosticsFailureCode, } from "./private-local-service-log.js";
+export type { PrivateLocalEffectiveModel } from "./private-local-effective-model.js";
+export { runPrivateLocalWorkerServer, type PrivateLocalWorkerServerIo, } from "./private-local-worker-server.js";
+/** The service answered a selection with a failure status and no readable failure body. */
+export declare class LocalServiceUnreadableResponse extends Error {
+    readonly name = "LocalServiceUnreadableResponse";
+    readonly status: number;
+    constructor(status: number, cause: unknown);
+}
+/**
+ * A newer client replaced the service this running client reached with one
+ * that speaks another protocol. Only restarting the window can reconnect it.
+ */
+export declare class LocalServiceUpdated extends Error {
+    readonly name = "LocalServiceUpdated";
+    constructor();
+}
+/** Construction does not start a service or open a store. Call start/connect explicitly. */
+export declare function createPrivateLocalServiceManager(options?: {
+    /** Selected host home, independent of an explicit service directory. */
+    home?: string;
+    directory?: string;
+    eventSource?: ShiitakeEventSourceConstructor;
+    executable?: string;
+    /** Test/client override; production captures the invoking client's PATH. */
+    executionPath?: string;
+    /** How long to wait for a live service that misses its handshake (default 60 s). */
+    busyServiceWaitMs?: number;
+    /**
+     * Where a failed cleanup (for example an auth cancel the service could not
+     * take) is recorded with its cause. Clients with an operator log pass it;
+     * the default writes one bounded line to stderr.
+     */
+    reportCleanupFailure?: (cause: unknown) => void;
+}): PrivateLocalServiceManager;