@knpkv/relay 0.0.0-stage → 0.2.0

package/LICENSE-THIRD-PARTY.md

@@ -0,0 +1,29 @@
+# Third-party notices
+
+`dist/index.js` bundles code from these packages of [Pi](https://github.com/earendil-works/pi), each published
+under the MIT licence below: `@earendil-works/pi-durable`, `@earendil-works/chord` and `@earendil-works/pi-ai`
+(version 1.0.4).
+
+```
+MIT License
+
+Copyright (c) 2025 Mario Zechner
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+```

package/README.md

@@ -1,3 +1,111 @@
-# Temporary Holding Version
+# @knpkv/relay
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The Relay agent harness every knpkv product mounts. One durable conversation per product object, model
+turns through the user's own Claude Code or Codex CLI login, product capabilities behind one permission
+gate, and one event stream for the dock.
+
+## Mental model
+
+- **One session per object.** A session is keyed by an `ObjectRef` (`{ product, kind, id }`), so a
+  question about the same pull request finds its history again, across restarts.
+- **Durable by construction.** Sessions run on [Pi Durable](https://github.com/earendil-works/pi) over
+  SQLite (`@libsql/client`, so Node and Bun both work). Every input, model turn and tool call is committed
+  before it is shown. A process killed mid-run continues from its last checkpoint when the store is next
+  opened, and a `write` that was interrupted is never run twice; the model is told it was interrupted.
+- **Capabilities are the only way in.** A product declares each action once as a `@knpkv/capability`
+  contract (Schema input, output and declared failures, plus its access) and binds a handler with
+  `implement`; `register` hands it to Relay. The model sees a declared failure's reason and fix, never a
+  defect's internals.
+  - `read` runs when the model calls it, and reruns after a crash.
+  - `write` waits for the person to confirm the exact action (`ConfirmationRequired` carries verb, target,
+    arguments and whether it is reversible). The decision is remembered per call, so a restart neither asks
+    again nor runs a declined action.
+  - `host` is refused until herdr Approvals are wired.
+- **Your login, not ours.** Each turn runs `claude --print` or `codex exec` with every CLI tool withheld,
+  asking for one structured answer (a reply or tool calls). Relay never holds a provider credential and never
+  registers pi-ai's own providers, including its claude.ai and ChatGPT OAuth flows.
+
+## Use
+
+```ts
+import { claudeCodeBackend, layer, register } from "@knpkv/relay"
+import { Effect, Layer } from "effect"
+
+const RelayLive = Layer.unwrap(
+  Effect.gen(function* () {
+    const claude = yield* claudeCodeBackend({ cwd })
+    return layer({
+      storePath, // e.g. <product data dir>/relay/sessions.sqlite
+      instructions: "You are Relay inside CodeCommit…",
+      capabilities: [register(getPullRequest), register(postComment)],
+      backends: [claude]
+    })
+  })
+)
+```
+
+`RelayHarness` then offers:
+
+- `send(ref, text, requestId, { backend?, context? })`: `requestId` makes a retried send land once and names
+  the run that answers it. `backend` switches the session from its next turn on (`RelayBackendNotConfigured`
+  otherwise). `context` is what the person attached, as the product renders it (`{ label, body }`): it is
+  placed just before the message for the model, and never appears in the transcript or the Snapshot.
+- `events(ref)`: a `Snapshot` first, with each message's `id`, the `runIds` of a run in flight and the
+  requestIds still `queued`. Then:
+  - `MessageQueued { requestId }`, then `MessagePlaced { id, requestId, text }` when a run takes it, or
+    `MessageWithdrawn { requestId }` when it is cancelled first.
+  - `RunStarted { runIds }` and `TextDelta`.
+  - `ToolStarted` and `ToolFinished`, each with a server-built, display-safe `summary`. A finished call carries
+    its citations, and a write whose product projects one carries a `receipt { summary, providerId, link? }`
+    (`register(capability, { receipt })`).
+  - `ConfirmationRequired`, then `ConfirmationResolved { decision: confirmed | declined | expired }`. A card
+    turns to past tense only on the latter.
+  - `RunFinished`, `RunFailed` or `Cancelled`, with the `runIds` the run answered.
+- `decide(callId, allow)`: `RelayDecisionNotPending` says why an answer can't apply: `Decided`, `Expired` (the run
+  ended first) or `Unknown`. Kept for the process's lifetime.
+- `cancel(ref, runId)`: withdraws a queued message alone, or stops the run in flight; `RelayRunNotActive` when no
+  run answers `runId`.
+- `session(ref)`: the session's tools and the backend its next turn runs on.
+- `backends`: `Unverified` (the CLI answered `--version`), `Ready` (a turn answered), or `Unavailable` with
+  `NotInstalled`, `SignedOut`, `Misconfigured` or `NoCapability` and a one-line fix. Observed, never persisted.
+  `SignedOut` comes from an `AuthenticationError` turn failure.
+
+## In the browser: `@knpkv/relay/wire`
+
+The contract a product's `/…/relay` routes speak, as a separate browser bundle that imports only
+`effect` and `@knpkv/capability`. It holds the harness's event and session schemas, plus:
+
+- `RelayStreamFrame`: one `data:` frame of `GET events`, a `RelayEvent`, `Unauthorized` or `StreamFailed`;
+- `RelayMessageRequest`, `RelayCancelRequest` and `RelayDecisionRequest`, the write bodies, and `RelayMessageAccepted`;
+- the typed refusals: `RelayUnavailableError` (503, with the fix), `RelayConflictError` (409, with the
+  `RelayConflictState` found) and `RelayBadRequestError` (400).
+
+A product narrows `ref` to its own objects and may add a typed `context` to a message. The build fails if
+the bundle reaches anything else, and `pnpm test:pack` checks the packed `dist/wire.js` again.
+`@knpkv/relay-product/client` reads a conversation through it.
+
+## Security boundaries
+
+- The session store holds conversation content. Its directory is created `0700` and the database `0600`;
+  a store directory, database or SQLite sidecar (`-wal`, `-shm`) that is a symbolic link, even a dangling one, fails with `RelayStoreLinked` before anything is
+  re-permissioned or written;
+  it is never logged, never sent to telemetry, and never served on unauthenticated routes.
+- One process owns a store: it holds an exclusive SQLite lock on `<store>.lock` (owner-only), so a second
+  owner fails with `RelayStoreLocked`. Closing the harness frees the store at once, so the same process can
+  open it again; the OS releases the lock if the owner dies. The lock is the runtime's own SQLite
+  (`node:sqlite` on Node, `bun:sqlite` on Bun), loaded when a store opens and used only through `exec`,
+  because libsql keeps a closed connection, and its locks, until its statements are garbage-collected.
+- Provider credentials stay with the user's CLI. Relay only spawns `claude`/`codex` with all of their tools
+  withheld.
+
+## Dependency note
+
+Relay bundles the Pi modules it uses (pi-durable, chord, and pi-ai's core) into `dist/index.js`. Their MIT
+notice ships in `LICENSE-THIRD-PARTY.md`. Pi's packages declare the Anthropic, OpenAI, Google and Bedrock SDKs
+and esbuild as hard dependencies, but nothing Relay loads imports them. Bundling keeps all of that out of
+every product that mounts Relay. The installed dependencies are `typebox`, `@libsql/client`, `effect` and
+Relay's sibling `@knpkv` packages.
+
+`pnpm test:pack` holds the package to that: the bundle may import only declared dependencies and Node
+built-ins, and a dynamic import may reach nothing but a Node built-in. The bundle is temporary, until upstream
+makes those dependencies optional (ADR-0009, amendment of 2026-10-07).

package/dist/backends.d.ts

@@ -0,0 +1,26 @@
+import { Effect, FileSystem, Layer } from "effect";
+import { ChildProcessSpawner } from "effect/process";
+import { RelayBackendUnavailable } from "./harness.js";
+export interface CliBackendOptions {
+    /** Working directory the CLI starts in. It reads no files there: every tool is withheld. */
+    readonly cwd: string;
+    /** Model override; omitted means the CLI's configured default. */
+    readonly model?: string | undefined;
+}
+/** Claude Code on the user's own login. */
+export declare const claudeCodeBackend: (options: CliBackendOptions) => Effect.Effect<{
+    id: "claude-code";
+    name: string;
+    model: Layer.Layer<import("effect/ai/LanguageModel").LanguageModel | import("effect/ai/Model").ModelName | import("effect/ai/Model").ProviderName, never, never>;
+    probe: Effect.Effect<string, RelayBackendUnavailable, never>;
+    signInFix: string;
+}, never, ChildProcessSpawner.ChildProcessSpawner>;
+/** Codex on the user's own ChatGPT login. */
+export declare const codexCliBackend: (options: CliBackendOptions) => Effect.Effect<{
+    id: "codex-cli";
+    name: string;
+    model: Layer.Layer<import("effect/ai/LanguageModel").LanguageModel | import("effect/ai/Model").ModelName | import("effect/ai/Model").ProviderName, never, never>;
+    probe: Effect.Effect<string, RelayBackendUnavailable, never>;
+    signInFix: string;
+}, never, ChildProcessSpawner.ChildProcessSpawner | FileSystem.FileSystem>;
+//# sourceMappingURL=backends.d.ts.map

package/dist/backends.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"backends.d.ts","sourceRoot":"","sources":["../src/backends.ts"],"names":[],"mappings":"AAgBA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAA;AAClD,OAAO,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AACpD,OAAO,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAA;AAGtD,MAAM,WAAW,iBAAiB;IAChC,4FAA4F;IAC5F,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,kEAAkE;IAClE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;CACpC;AA8BD,2CAA2C;AAC3C,eAAO,MAAM,iBAAiB;;;;;;kDAgB5B,CAAA;AAEF,6CAA6C;AAC7C,eAAO,MAAM,eAAe;;;;;;0EAoB1B,CAAA"}

package/dist/harness.d.ts

@@ -0,0 +1,132 @@
+import { Context, Crypto, Effect, FileSystem, Layer, Path, Schema, Scope, Stream } from "effect";
+import type { LanguageModel } from "effect/ai";
+import { RelayBackendId } from "./model.js";
+import type { BackendStatus, ObjectRef, RelayEvent, SessionInfo, SessionTool } from "./model.js";
+import type { RegisteredCapability } from "./registry.js";
+declare const RelayStoreLocked_base: Schema.Class<RelayStoreLocked, Schema.TaggedStruct<"RelayStoreLocked", {
+    readonly path: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** Another process already owns this Relay store. */
+export declare class RelayStoreLocked extends RelayStoreLocked_base {
+}
+declare const RelayStoreLinked_base: Schema.Class<RelayStoreLinked, Schema.TaggedStruct<"RelayStoreLinked", {
+    readonly path: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/**
+ * The store directory or database is a symbolic link. Relay refuses it rather than re-permission and
+ * write conversation content wherever the link points.
+ */
+export declare class RelayStoreLinked extends RelayStoreLinked_base {
+}
+declare const RelayStoreFailed_base: Schema.Class<RelayStoreFailed, Schema.TaggedStruct<"RelayStoreFailed", {
+    readonly operation: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** The Relay store could not be opened or read. `message` names the operation and the fix. */
+export declare class RelayStoreFailed extends RelayStoreFailed_base {
+}
+declare const RelayDecisionNotPending_base: Schema.Class<RelayDecisionNotPending, Schema.TaggedStruct<"RelayDecisionNotPending", {
+    readonly callId: Schema.String;
+    readonly state: Schema.TaggedUnion<{
+        readonly Decided: Schema.TaggedStruct<"Decided", {
+            readonly allow: Schema.Boolean;
+        }>;
+        readonly Expired: Schema.TaggedStruct<"Expired", {}>;
+        readonly Unknown: Schema.TaggedStruct<"Unknown", {}>;
+    }>;
+}>, import("effect/Cause").YieldableError>;
+/** No confirmation is waiting for this call; `state` says whether it was answered, withdrawn, or never asked. */
+export declare class RelayDecisionNotPending extends RelayDecisionNotPending_base {
+}
+declare const RelayRunNotActive_base: Schema.Class<RelayRunNotActive, Schema.TaggedStruct<"RelayRunNotActive", {
+    readonly runId: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** No run of this session answers `runId`: it finished, or never started. */
+export declare class RelayRunNotActive extends RelayRunNotActive_base {
+}
+declare const RelayBackendNotConfigured_base: Schema.Class<RelayBackendNotConfigured, Schema.TaggedStruct<"RelayBackendNotConfigured", {
+    readonly backend: Schema.Literals<readonly ["claude-code", "codex-cli"]>;
+}>, import("effect/Cause").YieldableError>;
+/** The session asked for a backend this product did not configure. */
+export declare class RelayBackendNotConfigured extends RelayBackendNotConfigured_base {
+}
+declare const RelayBackendUnavailable_base: Schema.Class<RelayBackendUnavailable, Schema.TaggedStruct<"RelayBackendUnavailable", {
+    readonly cause: Schema.Literals<readonly ["NotInstalled", "SignedOut", "Misconfigured", "NoCapability"]>;
+    readonly fix: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+/** A backend's CLI can't be used. `fix` is the one action that makes it usable. */
+export declare class RelayBackendUnavailable extends RelayBackendUnavailable_base {
+}
+/** One backend the harness can run turns on, with the `LanguageModel` that reaches it. */
+export interface RelayBackend {
+    readonly id: RelayBackendId;
+    readonly name: string;
+    readonly model: Layer.Layer<LanguageModel.LanguageModel>;
+    /** The CLI's version, read without a model call; fails when it is missing or unusable. */
+    readonly probe: Effect.Effect<string, RelayBackendUnavailable>;
+    /** The one line that signs the CLI back in, shown when a turn is refused for its login. */
+    readonly signInFix: string;
+}
+export interface RelayHarnessOptions<Requirements> {
+    /** SQLite file of this product's Relay sessions. Owner-only; never on a shared path. */
+    readonly storePath: string;
+    /** The product's standing instructions for Relay. */
+    readonly instructions: string;
+    readonly capabilities: ReadonlyArray<RegisteredCapability<Requirements>>;
+    /** The first backend is the default for new sessions. */
+    readonly backends: readonly [RelayBackend, ...ReadonlyArray<RelayBackend>];
+}
+/**
+ * Context the person attached to one message, as the product renders it for the model: `label` names
+ * what it is, `body` is the text the model reads. It reaches the model's context, never the transcript.
+ */
+export interface MessageContext {
+    readonly label: string;
+    readonly body: string;
+}
+export interface SendOptions {
+    /** Switch the session to this backend from its next turn on. */
+    readonly backend?: RelayBackendId | undefined;
+    /** Attached context, placed just before the message. */
+    readonly context?: ReadonlyArray<MessageContext> | undefined;
+}
+export interface RelayHarnessService {
+    /**
+     * Send a message to the session about `ref`. `requestId` makes a retried send land once and names the run
+     * that answers it. `backend` switches the session to that backend from its next turn on.
+     */
+    readonly send: (ref: ObjectRef, text: string, requestId: string, options?: SendOptions) => Effect.Effect<void, RelayStoreFailed | RelayBackendNotConfigured>;
+    /** The session's events: a `Snapshot` first, then every change. Ends when the scope closes. */
+    readonly events: (ref: ObjectRef) => Stream.Stream<RelayEvent, RelayStoreFailed>;
+    /**
+     * Answer a confirmation pending in `ref`'s session. A call raised in another session is `Unknown` here and
+     * stays pending. Outcomes are remembered for the harness's lifetime, not across restarts.
+     */
+    readonly decide: (ref: ObjectRef, callId: string, allow: boolean) => Effect.Effect<void, RelayDecisionNotPending | RelayStoreFailed>;
+    /**
+     * Stop the run answering `runId`. A message still queued is withdrawn alone; a run in flight stops whole,
+     * with every message it took. Nothing already committed is undone.
+     */
+    readonly cancel: (ref: ObjectRef, runId: string) => Effect.Effect<void, RelayStoreFailed | RelayRunNotActive>;
+    /** The tools the dock lists for a session, and the backend its next turn runs on. */
+    readonly session: (ref: ObjectRef) => Effect.Effect<SessionInfo, RelayStoreFailed>;
+    /** Every configured backend's status, in configuration order. */
+    readonly backends: Effect.Effect<ReadonlyArray<BackendStatus>>;
+    /** The tools the dock lists for a session. */
+    readonly tools: ReadonlyArray<SessionTool>;
+}
+declare const RelayHarness_base: Context.ServiceClass<RelayHarness, "@knpkv/relay/RelayHarness", RelayHarnessService>;
+export declare class RelayHarness extends RelayHarness_base {
+}
+/**
+ * Build the harness for one product. One attempt's resources (the store lock, the store, the harness) live in
+ * their own scope: an attempt that fails releases them at once, so a retry in the same scope can take the
+ * store; one that succeeds keeps them until the caller's scope closes.
+ */
+export declare const make: <Requirements>(options: RelayHarnessOptions<Requirements>) => Effect.Effect<RelayHarnessService, RelayStoreFailed | RelayStoreLinked | RelayStoreLocked, Crypto.Crypto | FileSystem.FileSystem | Path.Path | Scope.Scope | Exclude<Requirements, Scope.Scope>>;
+/** Build the harness as a scoped layer: the store closes, and the lock is released, with the scope. */
+export declare const layer: <Requirements>(options: RelayHarnessOptions<Requirements>) => Layer.Layer<RelayHarness, RelayStoreFailed | RelayStoreLinked | RelayStoreLocked, Crypto.Crypto | FileSystem.FileSystem | Path.Path | Exclude<Exclude<Requirements, Scope.Scope>, Scope.Scope>>;
+export {};
+//# sourceMappingURL=harness.d.ts.map

package/dist/harness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harness.d.ts","sourceRoot":"","sources":["../src/harness.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Relay: the agent harness every product mounts.
+ *
+ * @since 0.1.0
+ */
+export { claudeCodeBackend, codexCliBackend } from "./backends.js";
+export type { CliBackendOptions } from "./backends.js";
+export { layer, make, RelayBackendNotConfigured, RelayBackendUnavailable, RelayDecisionNotPending, RelayHarness, RelayRunNotActive, RelayStoreFailed, RelayStoreLinked, RelayStoreLocked } from "./harness.js";
+export type { MessageContext, RelayBackend, RelayHarnessOptions, RelayHarnessService, SendOptions } from "./harness.js";
+export { BackendStatus, BackendUnavailableCause, CapabilityAccess, DecisionState, ObjectRef, objectRefKey, RelayBackendId, RelayEvent, RelayProduct, SessionInfo, SessionTool, WriteReceipt } from "./model.js";
+export { register } from "./registry.js";
+export type { DisplayOptions, Gate, RegisteredCapability } from "./registry.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAClE,YAAY,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAA;AACtD,OAAO,EACL,KAAK,EACL,IAAI,EACJ,yBAAyB,EACzB,uBAAuB,EACvB,uBAAuB,EACvB,YAAY,EACZ,iBAAiB,EACjB,gBAAgB,EAChB,gBAAgB,EAChB,gBAAgB,EACjB,MAAM,cAAc,CAAA;AACrB,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,mBAAmB,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AACvH,OAAO,EACL,aAAa,EACb,uBAAuB,EACvB,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,YAAY,EACZ,cAAc,EACd,UAAU,EACV,YAAY,EACZ,WAAW,EACX,WAAW,EACX,YAAY,EACb,MAAM,YAAY,CAAA;AACnB,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA;AACxC,YAAY,EAAE,cAAc,EAAE,IAAI,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA"}