@akira-tl/forgerelay 0.1.0

package/dist/mcp/server-instructions.js

@@ -0,0 +1,78 @@
+export const toolNames = {
+    openWorkspace: "open_workspace",
+    closeWorktree: "close_worktree",
+    read: "read",
+    write: "write",
+    edit: "edit",
+    grep: "grep",
+    glob: "glob",
+    ls: "ls",
+    shell: "bash",
+};
+export function buildServerInstructions(config, context = {}) {
+    return joinInstructions(capabilityContractInstructions(config, context), selectedWorkflowInstructions(config), config.appendInstructions);
+}
+export function buildToolDescriptions(config) {
+    const skillCapability = config.skillsEnabled
+        ? " Advertised skill paths may be outside the workspace; only advertised SKILL.md files and files under already-loaded skill directories are readable."
+        : "";
+    const shellSurface = config.toolMode === "minimal"
+        ? ` In minimal tool mode, ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} are disabled, so shell commands may be used for equivalent search and directory inspection.`
+        : "";
+    return {
+        read: `Read a file inside an open workspace. Instruction files returned by ${toolNames.openWorkspace} and advertised skill files are also readable when applicable.${skillCapability} Call ${toolNames.openWorkspace} first and pass workspaceId.`,
+        write: `Create or completely overwrite a file inside an open workspace. The path is resolved within the workspace filesystem boundary. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
+        edit: `Edit one file inside an open workspace by replacing exact text blocks. Each oldText must match a unique, non-overlapping region of the original file. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
+        applyPatch: `Apply one Codex-style patch inside an open workspace. Supports adding, overwriting, updating, deleting, and moving files. Paths must be relative to the workspace. Call ${toolNames.openWorkspace} first and pass workspaceId.`,
+        shell: `Run a shell command inside an open workspace.${shellSurface} Commands execute with the local user's authority; workspace filesystem containment does not make shell execution a sandbox. Do not use ${toolNames.shell} to create or modify project files; use ${toolNames.edit} or ${toolNames.write} for file changes. Call ${toolNames.openWorkspace} first and pass workspaceId. This capability should only be exposed behind strong authentication.`,
+        shellCommand: "Shell command to run with the local user's authority.",
+    };
+}
+function capabilityContractInstructions(config, context) {
+    const workspaceLifecycle = config.toolMode === "codex"
+        ? `Use ForgeRelay as a local coding workspace. Default to the user's existing checkout and reuse its workspaceId. Only open mode=\"worktree\" when the user explicitly asks for isolated or parallel work. Managed worktrees use dedicated forgerelay/* branches, not detached HEADs. When work in a managed worktree is complete and verified, call ${toolNames.closeWorktree}; it commits remaining worktree changes, fast-forwards the original target branch only when safe, then removes the worktree and its branch. If the target branch diverged or the source checkout is dirty, closing is refused and the worktree is preserved.`
+        : `Use ForgeRelay as a local coding workspace. Default to the user's existing checkout and reuse its workspaceId for later file, search, edit, write, show-changes, and shell tools. Only open mode=\"worktree\" when the user explicitly asks for isolated or parallel work. Managed worktrees use dedicated forgerelay/* branches, not detached HEADs. When work in a managed worktree is complete and verified, call ${toolNames.closeWorktree}; it commits remaining worktree changes, fast-forwards the original target branch only when safe, then removes the worktree and its branch. If the target branch diverged or the source checkout is dirty, closing is refused and the worktree is preserved.`;
+    const agents = `Follow instructions returned by ${toolNames.openWorkspace}. Before working under a path listed in availableAgentsFiles, use ${toolNames.read} to inspect that instruction file and follow it.`;
+    const skills = config.skillsEnabled
+        ? `When ${toolNames.openWorkspace} returns available skills and a task matches a skill, use ${toolNames.read} to read that skill's path before proceeding. Skill paths may be outside the workspace, but ${toolNames.read} only permits advertised SKILL.md files and files under already-loaded skill directories.`
+        : "";
+    const toolSurface = toolSurfaceInstructions(config);
+    const artifact = config.artifactsEnabled && context.artifactDownloadSupported
+        ? "When the user supplies or generates a file that is not present on the ForgeRelay host, use download_artifact with its native file value, the existing workspace ID, and a suitable relative destination path chosen from the user's request and project structure. The tool refuses to overwrite an existing destination and returns the normalized workspace-relative path. Use normal workspace tools when explicit inspection, replacement, movement, renaming, or deletion is needed. Do not recreate binary files with write/edit calls or place signed URLs, native file objects, base64 content, or invented host paths in shell commands or logs."
+        : "";
+    const showChanges = config.widgets === "changes"
+        ? "If the turn successfully modifies files by creating, editing, overwriting, deleting, moving, or applying patches, call show_changes exactly once for that workspace after the final related file change and before your final response so the user can inspect the aggregate diff for that turn. Do not call it after every individual file change; do not skip it because individual file-change tools already returned diffs."
+        : "";
+    return joinInstructions(workspaceLifecycle, agents, skills, toolSurface, artifact, showChanges);
+}
+function toolSurfaceInstructions(config) {
+    if (config.toolMode === "codex") {
+        return `In codex tool mode, workspace file and command operations use ${toolNames.read}, apply_patch, exec_command, and write_stdin.`;
+    }
+    if (config.toolMode === "full") {
+        return `In full tool mode, dedicated ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} inspection tools are available alongside the core workspace tools.`;
+    }
+    return `In minimal tool mode, dedicated ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} inspection tools are disabled; the core workspace tools remain available.`;
+}
+function selectedWorkflowInstructions(config) {
+    if (config.workflowInstructions === false)
+        return "";
+    if (typeof config.workflowInstructions === "string")
+        return config.workflowInstructions;
+    return defaultWorkflowInstructions(config);
+}
+function defaultWorkflowInstructions(config) {
+    if (config.toolMode === "codex") {
+        return `Use ${toolNames.read} for direct file reads, apply_patch for all file modifications, exec_command for inspection, tests, builds, and other commands, and write_stdin to poll or interact with running processes.`;
+    }
+    const inspection = config.toolMode === "full"
+        ? `Prefer ${toolNames.read}, ${toolNames.grep}, ${toolNames.glob}, and ${toolNames.ls} for file inspection.`
+        : `Use ${toolNames.shell} with command-line tools such as grep, rg, find, ls, and tree for search and directory inspection.`;
+    return joinInstructions(inspection, `Prefer ${toolNames.edit} for targeted modifications, ${toolNames.write} only for new files or complete rewrites, and ${toolNames.shell} for tests, builds, git inspection, package scripts, and commands that are better executed by the shell.`, `Do not create or modify files with ${toolNames.shell}; avoid shell redirection, heredocs, tee, sed -i, perl -i, node/python/ruby scripts, or any command whose purpose is to write project files.`);
+}
+function joinInstructions(...parts) {
+    return parts
+        .map((part) => part?.trim())
+        .filter((part) => Boolean(part))
+        .join(" ");
+}

package/dist/mcp-sessions.js

@@ -0,0 +1,56 @@
+export class McpSessionRegistry {
+    sessions = new Map();
+    now;
+    constructor(options = {}) {
+        this.now = options.now ?? Date.now;
+    }
+    get size() {
+        return this.sessions.size;
+    }
+    register(sessionId, transport) {
+        this.sessions.set(sessionId, {
+            transport,
+            lastActivityAt: this.now(),
+        });
+    }
+    get(sessionId) {
+        const entry = this.sessions.get(sessionId);
+        if (!entry)
+            return undefined;
+        entry.lastActivityAt = this.now();
+        return entry.transport;
+    }
+    remove(sessionId) {
+        return this.sessions.delete(sessionId);
+    }
+    async closeIdle(idleTimeoutMs) {
+        const cutoff = this.now() - idleTimeoutMs;
+        const idleSessions = [];
+        for (const [sessionId, entry] of this.sessions) {
+            if (entry.lastActivityAt > cutoff)
+                continue;
+            this.sessions.delete(sessionId);
+            idleSessions.push({ sessionId, transport: entry.transport });
+        }
+        return closeSessions(idleSessions);
+    }
+    async closeAll() {
+        const sessions = Array.from(this.sessions, ([sessionId, entry]) => ({
+            sessionId,
+            transport: entry.transport,
+        }));
+        this.sessions.clear();
+        return closeSessions(sessions);
+    }
+}
+async function closeSessions(sessions) {
+    return Promise.all(sessions.map(async ({ sessionId, transport }) => {
+        try {
+            await transport.close();
+            return { sessionId };
+        }
+        catch (error) {
+            return { sessionId, error };
+        }
+    }));
+}

package/dist/oauth-provider.js

@@ -0,0 +1,237 @@
+import { timingSafeEqual, randomBytes, randomUUID, createHash } from "node:crypto";
+import { AccessDeniedError, InvalidGrantError, InvalidRequestError, InvalidTokenError } from "@modelcontextprotocol/sdk/server/auth/errors.js";
+import { checkResourceAllowed, resourceUrlFromServerUrl } from "@modelcontextprotocol/sdk/shared/auth-utils.js";
+import { SqliteOAuthClientsStore, SqliteOAuthStore } from "./oauth-store.js";
+const CODE_TTL_MS = 5 * 60 * 1000;
+function randomToken() {
+    return randomBytes(32).toString("base64url");
+}
+function safeEquals(a, b) {
+    const left = Buffer.from(a);
+    const right = Buffer.from(b);
+    if (left.byteLength !== right.byteLength)
+        return false;
+    return timingSafeEqual(left, right);
+}
+function htmlEscape(value) {
+    return value
+        .replaceAll("&", "&")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}
+function formHtml(params) {
+    const scopeText = params.scopes.length > 0 ? params.scopes.join(" ") : "devspace";
+    const resourceText = params.resource?.href ?? "ForgeRelay MCP endpoint";
+    const error = params.error
+        ? `<p class="error">${htmlEscape(params.error)}</p>`
+        : "";
+    const hiddenFields = Object.entries(params.fields)
+        .filter((entry) => entry[1] !== undefined)
+        .map(([name, value]) => `        <input type="hidden" name="${htmlEscape(name)}" value="${htmlEscape(value)}" />`)
+        .join("\n");
+    return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>Connect ForgeRelay</title>
+    <style>
+      body { font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif; margin: 0; background: #0f172a; color: #e2e8f0; }
+      main { max-width: 440px; margin: 12vh auto; padding: 32px; background: #111827; border: 1px solid #334155; border-radius: 18px; box-shadow: 0 24px 80px rgba(0,0,0,.35); }
+      h1 { margin: 0 0 12px; font-size: 28px; }
+      p { line-height: 1.5; color: #cbd5e1; }
+      dl { padding: 16px; background: #020617; border-radius: 12px; }
+      dt { color: #94a3b8; font-size: 12px; text-transform: uppercase; letter-spacing: .06em; }
+      dd { margin: 4px 0 12px; word-break: break-word; }
+      label { display: block; margin: 18px 0 8px; font-weight: 600; }
+      input { box-sizing: border-box; width: 100%; padding: 12px 14px; border-radius: 10px; border: 1px solid #475569; background: #020617; color: #e2e8f0; font-size: 16px; }
+      button { margin-top: 18px; width: 100%; border: 0; border-radius: 10px; padding: 12px 14px; font-weight: 700; color: #020617; background: #38bdf8; cursor: pointer; }
+      .error { color: #fecaca; background: #7f1d1d; border-radius: 10px; padding: 10px 12px; }
+      .warning { color: #fde68a; }
+    </style>
+  </head>
+  <body>
+    <main>
+      <h1>Connect ForgeRelay</h1>
+      <p class="warning">Only approve this if you are intentionally connecting your own ChatGPT or MCP client to this local machine.</p>
+      ${error}
+      <dl>
+        <dt>Client</dt><dd>${htmlEscape(params.clientName)}</dd>
+        <dt>Scope</dt><dd>${htmlEscape(scopeText)}</dd>
+        <dt>Resource</dt><dd>${htmlEscape(resourceText)}</dd>
+      </dl>
+      <form method="post">
+${hiddenFields}
+        <label for="owner_token">Owner password</label>
+        <input id="owner_token" name="owner_token" type="password" autocomplete="current-password" autofocus required />
+        <button type="submit">Authorize ForgeRelay</button>
+      </form>
+    </main>
+  </body>
+</html>`;
+}
+function requestedScopesAllowed(requested, supported) {
+    return requested.every((scope) => supported.includes(scope));
+}
+export class SingleUserOAuthProvider {
+    config;
+    clientsStore;
+    codes = new Map();
+    oauthStore;
+    resourceServerUrl;
+    constructor(config, resourceServerUrl, stateDir) {
+        this.config = config;
+        this.resourceServerUrl = resourceUrlFromServerUrl(resourceServerUrl);
+        this.oauthStore = new SqliteOAuthStore(stateDir);
+        this.clientsStore = new SqliteOAuthClientsStore(this.oauthStore, config.allowedRedirectHosts);
+    }
+    async authorize(client, params, res) {
+        if (!params.resource || !checkResourceAllowed({ requestedResource: params.resource, configuredResource: this.resourceServerUrl })) {
+            throw new InvalidRequestError("Invalid or missing OAuth resource");
+        }
+        if (!requestedScopesAllowed(params.scopes ?? [], this.config.scopes)) {
+            throw new InvalidRequestError("Requested scope is not supported");
+        }
+        if (res.req.method !== "POST") {
+            res.status(200).setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(formHtml({
+                clientName: client.client_name ?? client.client_id,
+                scopes: params.scopes ?? this.config.scopes,
+                resource: params.resource,
+                fields: authorizationFormFields(client, params),
+            }));
+            return;
+        }
+        const providedToken = String(res.req.body?.owner_token ?? "");
+        if (!safeEquals(providedToken, this.config.ownerToken)) {
+            res.status(401).setHeader("Content-Type", "text/html; charset=utf-8");
+            res.send(formHtml({
+                error: "The Owner password was not accepted.",
+                clientName: client.client_name ?? client.client_id,
+                scopes: params.scopes ?? this.config.scopes,
+                resource: params.resource,
+                fields: authorizationFormFields(client, params),
+            }));
+            return;
+        }
+        const code = `code-${randomUUID()}`;
+        this.codes.set(code, {
+            clientId: client.client_id,
+            params,
+            expiresAtMs: Date.now() + CODE_TTL_MS,
+        });
+        const redirectUrl = new URL(params.redirectUri);
+        redirectUrl.searchParams.set("code", code);
+        if (params.state !== undefined)
+            redirectUrl.searchParams.set("state", params.state);
+        res.redirect(302, redirectUrl.href);
+    }
+    async challengeForAuthorizationCode(client, authorizationCode) {
+        const record = this.validCodeRecord(client, authorizationCode);
+        return record.params.codeChallenge;
+    }
+    async exchangeAuthorizationCode(client, authorizationCode, _codeVerifier, redirectUri, resource) {
+        const record = this.validCodeRecord(client, authorizationCode);
+        if (redirectUri && redirectUri !== record.params.redirectUri) {
+            throw new InvalidGrantError("redirect_uri does not match the authorization request");
+        }
+        if (resource && !checkResourceAllowed({ requestedResource: resource, configuredResource: this.resourceServerUrl })) {
+            throw new InvalidGrantError("Invalid resource");
+        }
+        this.codes.delete(authorizationCode);
+        return this.issueTokens(client.client_id, record.params.scopes ?? this.config.scopes, record.params.resource);
+    }
+    async exchangeRefreshToken(client, refreshToken, scopes, resource) {
+        const refreshTokenHash = hashToken(refreshToken);
+        const record = this.oauthStore.getRefreshToken(refreshTokenHash);
+        if (!record || record.clientId !== client.client_id || record.expiresAt < Math.floor(Date.now() / 1000)) {
+            throw new InvalidGrantError("Invalid refresh token");
+        }
+        if (resource && !checkResourceAllowed({ requestedResource: resource, configuredResource: this.resourceServerUrl })) {
+            throw new InvalidGrantError("Invalid resource");
+        }
+        const requestedScopes = scopes ?? record.scopes;
+        if (!requestedScopes.every((scope) => record.scopes.includes(scope))) {
+            throw new AccessDeniedError("Refresh token cannot grant requested scopes");
+        }
+        return this.issueTokens(client.client_id, requestedScopes, resource ?? (record.resource ? new URL(record.resource) : undefined), refreshTokenHash);
+    }
+    async verifyAccessToken(token) {
+        const record = this.oauthStore.getAccessToken(hashToken(token));
+        if (!record || record.expiresAt < Math.floor(Date.now() / 1000)) {
+            throw new InvalidTokenError("Invalid or expired access token");
+        }
+        return {
+            token,
+            clientId: record.clientId,
+            scopes: record.scopes,
+            expiresAt: record.expiresAt,
+            resource: record.resource ? new URL(record.resource) : undefined,
+        };
+    }
+    async revokeToken(_client, request) {
+        const hashed = hashToken(request.token);
+        this.oauthStore.deleteAccessToken(hashed);
+        this.oauthStore.deleteRefreshToken(hashed);
+    }
+    close() {
+        this.oauthStore.close();
+    }
+    validCodeRecord(client, authorizationCode) {
+        const record = this.codes.get(authorizationCode);
+        if (!record || record.clientId !== client.client_id || record.expiresAtMs < Date.now()) {
+            throw new InvalidGrantError("Invalid authorization code");
+        }
+        return record;
+    }
+    issueTokens(clientId, scopes, resource, consumedRefreshTokenHash) {
+        const now = Math.floor(Date.now() / 1000);
+        const accessToken = randomToken();
+        const refreshToken = randomToken();
+        const accessExpiresAt = now + this.config.accessTokenTtlSeconds;
+        const refreshExpiresAt = now + this.config.refreshTokenTtlSeconds;
+        const saved = this.oauthStore.saveTokenPair({
+            accessTokenHash: hashToken(accessToken),
+            accessToken: {
+                clientId,
+                scopes,
+                expiresAt: accessExpiresAt,
+                resource: resource?.href,
+            },
+            refreshTokenHash: hashToken(refreshToken),
+            refreshToken: {
+                clientId,
+                scopes,
+                expiresAt: refreshExpiresAt,
+                resource: resource?.href,
+            },
+        }, consumedRefreshTokenHash);
+        if (!saved) {
+            throw new InvalidGrantError("Invalid refresh token");
+        }
+        return {
+            access_token: accessToken,
+            token_type: "bearer",
+            expires_in: this.config.accessTokenTtlSeconds,
+            refresh_token: refreshToken,
+            scope: scopes.join(" "),
+        };
+    }
+}
+function authorizationFormFields(client, params) {
+    return {
+        response_type: "code",
+        client_id: client.client_id,
+        redirect_uri: params.redirectUri,
+        code_challenge: params.codeChallenge,
+        code_challenge_method: "S256",
+        scope: params.scopes?.join(" "),
+        state: params.state,
+        resource: params.resource?.href,
+    };
+}
+function hashToken(token) {
+    return createHash("sha256").update(token).digest("base64url");
+}

package/dist/oauth-store.js

@@ -0,0 +1,138 @@
+import { randomUUID } from "node:crypto";
+import { InvalidRequestError } from "@modelcontextprotocol/sdk/server/auth/errors.js";
+import { openDatabase } from "./db/client.js";
+function redirectHostAllowed(redirectUri, allowedHosts) {
+    let parsed;
+    try {
+        parsed = new URL(redirectUri);
+    }
+    catch {
+        return false;
+    }
+    if (["localhost", "127.0.0.1", "[::1]"].includes(parsed.hostname))
+        return true;
+    return allowedHosts.includes(parsed.hostname);
+}
+export class SqliteOAuthStore {
+    database;
+    constructor(stateDir) {
+        this.database = openDatabase(stateDir);
+        this.deleteExpiredTokens(Math.floor(Date.now() / 1000));
+    }
+    getClient(clientId) {
+        const row = this.database.sqlite
+            .prepare("select client_json from oauth_clients where client_id = ?")
+            .get(clientId);
+        return row ? JSON.parse(row.client_json) : undefined;
+    }
+    registerClient(client, allowedRedirectHosts) {
+        if (!client.redirect_uris.every((uri) => redirectHostAllowed(String(uri), allowedRedirectHosts))) {
+            throw new InvalidRequestError("Client redirect_uri is not allowed for this ForgeRelay server");
+        }
+        const now = Math.floor(Date.now() / 1000);
+        const registered = {
+            ...client,
+            client_id: `forgerelay-${randomUUID()}`,
+            client_id_issued_at: now,
+            token_endpoint_auth_method: client.token_endpoint_auth_method ?? "none",
+            grant_types: client.grant_types ?? ["authorization_code", "refresh_token"],
+            response_types: client.response_types ?? ["code"],
+        };
+        this.database.sqlite
+            .prepare("insert into oauth_clients (client_id, client_json, issued_at) values (?, ?, ?)")
+            .run(registered.client_id, JSON.stringify(registered), now);
+        return registered;
+    }
+    saveAccessToken(tokenHash, record) {
+        this.database.sqlite
+            .prepare(`insert into oauth_access_tokens (token_hash, client_id, scopes_json, expires_at, resource)
+         values (?, ?, ?, ?, ?)
+         on conflict(token_hash) do update set
+           client_id = excluded.client_id,
+           scopes_json = excluded.scopes_json,
+           expires_at = excluded.expires_at,
+           resource = excluded.resource`)
+            .run(tokenHash, record.clientId, JSON.stringify(record.scopes), record.expiresAt, record.resource ?? null);
+    }
+    getAccessToken(tokenHash) {
+        const row = this.database.sqlite
+            .prepare("select client_id, scopes_json, expires_at, resource from oauth_access_tokens where token_hash = ?")
+            .get(tokenHash);
+        return row ? rowToAccessTokenRecord(row) : undefined;
+    }
+    deleteAccessToken(tokenHash) {
+        this.database.sqlite.prepare("delete from oauth_access_tokens where token_hash = ?").run(tokenHash);
+    }
+    saveRefreshToken(tokenHash, record) {
+        this.database.sqlite
+            .prepare(`insert into oauth_refresh_tokens (token_hash, client_id, scopes_json, expires_at, resource)
+         values (?, ?, ?, ?, ?)
+         on conflict(token_hash) do update set
+           client_id = excluded.client_id,
+           scopes_json = excluded.scopes_json,
+           expires_at = excluded.expires_at,
+           resource = excluded.resource`)
+            .run(tokenHash, record.clientId, JSON.stringify(record.scopes), record.expiresAt, record.resource ?? null);
+    }
+    saveTokenPair(pair, consumedRefreshTokenHash) {
+        const save = this.database.sqlite.transaction(() => {
+            if (consumedRefreshTokenHash) {
+                const result = this.database.sqlite
+                    .prepare("delete from oauth_refresh_tokens where token_hash = ?")
+                    .run(consumedRefreshTokenHash);
+                if (result.changes !== 1)
+                    return false;
+            }
+            this.saveAccessToken(pair.accessTokenHash, pair.accessToken);
+            this.saveRefreshToken(pair.refreshTokenHash, pair.refreshToken);
+            return true;
+        });
+        return save.immediate();
+    }
+    getRefreshToken(tokenHash) {
+        const row = this.database.sqlite
+            .prepare("select client_id, scopes_json, expires_at, resource from oauth_refresh_tokens where token_hash = ?")
+            .get(tokenHash);
+        return row ? rowToRefreshTokenRecord(row) : undefined;
+    }
+    deleteRefreshToken(tokenHash) {
+        this.database.sqlite.prepare("delete from oauth_refresh_tokens where token_hash = ?").run(tokenHash);
+    }
+    close() {
+        this.database.close();
+    }
+    deleteExpiredTokens(nowSeconds) {
+        this.database.sqlite.prepare("delete from oauth_access_tokens where expires_at < ?").run(nowSeconds);
+        this.database.sqlite.prepare("delete from oauth_refresh_tokens where expires_at < ?").run(nowSeconds);
+    }
+}
+export class SqliteOAuthClientsStore {
+    store;
+    allowedRedirectHosts;
+    constructor(store, allowedRedirectHosts) {
+        this.store = store;
+        this.allowedRedirectHosts = allowedRedirectHosts;
+    }
+    getClient(clientId) {
+        return this.store.getClient(clientId);
+    }
+    registerClient(client) {
+        return this.store.registerClient(client, this.allowedRedirectHosts);
+    }
+}
+function rowToAccessTokenRecord(row) {
+    return {
+        clientId: row.client_id,
+        scopes: JSON.parse(row.scopes_json),
+        expiresAt: row.expires_at,
+        resource: row.resource ?? undefined,
+    };
+}
+function rowToRefreshTokenRecord(row) {
+    return {
+        clientId: row.client_id,
+        scopes: JSON.parse(row.scopes_json),
+        expiresAt: row.expires_at,
+        resource: row.resource ?? undefined,
+    };
+}

package/dist/pi-tools.js

@@ -0,0 +1,81 @@
+import { createBashTool, createEditTool, createFindTool, createGrepTool, createLsTool, createReadTool, createWriteTool, } from "@earendil-works/pi-coding-agent";
+import { resolveAllowedPath } from "./roots.js";
+function toMcpContent(result) {
+    return result.content.map((content) => {
+        if (content.type === "text") {
+            return { type: "text", text: content.text };
+        }
+        return {
+            type: "image",
+            data: content.data,
+            mimeType: content.mimeType,
+        };
+    });
+}
+function formatToolError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return [{ type: "text", text: message }];
+}
+async function runTool(execute, input, context) {
+    try {
+        const result = await execute(input);
+        return {
+            content: toMcpContent(result),
+            details: result.details,
+        };
+    }
+    catch (error) {
+        return { content: formatToolError(error), isError: true };
+    }
+}
+export async function readFileTool(input, context) {
+    const path = resolveAllowedPath(input.path, context.cwd, context.readRoots ?? [context.root]);
+    const tool = createReadTool(context.cwd);
+    return runTool((params) => tool.execute("read_file", params), {
+        path,
+        offset: input.offset,
+        limit: input.limit,
+    }, context);
+}
+export async function writeFileTool(input, context) {
+    const path = resolveAllowedPath(input.path, context.cwd, [context.root]);
+    const tool = createWriteTool(context.cwd);
+    return runTool((params) => tool.execute("write_file", params), {
+        path,
+        content: input.content,
+    }, context);
+}
+export async function editFileTool(input, context) {
+    const path = resolveAllowedPath(input.path, context.cwd, [context.root]);
+    const tool = createEditTool(context.cwd);
+    return runTool((params) => tool.execute("edit_file", params), {
+        path,
+        edits: input.edits,
+    }, context);
+}
+export async function grepFilesTool(input, context) {
+    if (input.path)
+        resolveAllowedPath(input.path, context.cwd, [context.root]);
+    const tool = createGrepTool(context.cwd);
+    return runTool((params) => tool.execute("grep_files", params), input, context);
+}
+export async function findFilesTool(input, context) {
+    if (input.path)
+        resolveAllowedPath(input.path, context.cwd, [context.root]);
+    const tool = createFindTool(context.cwd);
+    return runTool((params) => tool.execute("find_files", params), input, context);
+}
+export async function listDirectoryTool(input, context) {
+    if (input.path)
+        resolveAllowedPath(input.path, context.cwd, [context.root]);
+    const tool = createLsTool(context.cwd);
+    return runTool((params) => tool.execute("list_directory", params), input, context);
+}
+export async function runShellTool(input, context) {
+    const tool = createBashTool(context.cwd);
+    const timeout = input.timeout === undefined ? 30 : Math.min(input.timeout, 300);
+    return runTool((params) => tool.execute("run_shell", params), {
+        command: input.command,
+        timeout,
+    }, context);
+}

package/dist/process-platform.js

@@ -0,0 +1,49 @@
+import { basename } from "node:path";
+import { spawnSync } from "node:child_process";
+const defaultProcessTreeRuntime = {
+    platform: process.platform,
+    killGroup: (pid, signal) => process.kill(-pid, signal),
+    killWindowsTree: (pid) => {
+        const result = spawnSync("taskkill.exe", ["/pid", String(pid), "/T", "/F"], {
+            stdio: "ignore",
+            windowsHide: true,
+        });
+        return !result.error && result.status === 0;
+    },
+};
+const LOGIN_SHELLS = new Set(["bash", "ksh", "zsh"]);
+const POSIX_SHELLS = new Set(["ash", "dash", "sh"]);
+export function resolveShellCommand(command, platform = process.platform, environment = process.env) {
+    if (platform === "win32") {
+        return {
+            executable: environment.ComSpec ?? environment.COMSPEC ?? "cmd.exe",
+            args: ["/d", "/s", "/c", command],
+        };
+    }
+    const configuredShell = environment.SHELL;
+    const shellName = configuredShell ? basename(configuredShell) : "";
+    if (configuredShell && LOGIN_SHELLS.has(shellName)) {
+        return { executable: configuredShell, args: ["-lc", command] };
+    }
+    if (configuredShell && POSIX_SHELLS.has(shellName)) {
+        return { executable: configuredShell, args: ["-c", command] };
+    }
+    return { executable: "/bin/sh", args: ["-c", command] };
+}
+export function terminateProcessTree(child, signal, detached, runtime = defaultProcessTreeRuntime) {
+    if (runtime.platform === "win32" && child.pid) {
+        if (runtime.killWindowsTree(child.pid))
+            return;
+    }
+    else if (detached && child.pid) {
+        try {
+            runtime.killGroup(child.pid, signal);
+            return;
+        }
+        catch (error) {
+            if (error.code === "ESRCH")
+                return;
+        }
+    }
+    child.kill(signal);
+}