poe-code 3.0.191 → 3.0.192

package/packages/memory/dist/ingest.d.ts

@@ -1,3 +1,14 @@
+import { computeIngestKey, readCacheEntry, writeCacheEntry } from "./cache.js";
+import { reconcile, snapshot } from "./reconcile.js";
+import { computeTokenStats } from "./tokens.js";
 import type { IngestOptions, IngestResult, MemoryRoot } from "./types.js";
 export declare const INGEST_PROMPT_VERSION = "v1";
-export declare function ingest(root: MemoryRoot, opts: IngestOptions): Promise<IngestResult>;
+export type IngestRunners = {
+    computeIngestKey?: typeof computeIngestKey;
+    readCacheEntry?: typeof readCacheEntry;
+    writeCacheEntry?: typeof writeCacheEntry;
+    computeTokenStats?: typeof computeTokenStats;
+    snapshot?: typeof snapshot;
+    reconcile?: typeof reconcile;
+};
+export declare function ingest(root: MemoryRoot, opts: IngestOptions, runners?: IngestRunners): Promise<IngestResult>;

package/packages/memory/dist/ingest.js

@@ -1,12 +1,24 @@
 import * as fs from "node:fs/promises";
 import path from "node:path";
+import { spawn } from "@poe-code/agent-spawn";
 import { cacheEnabled, configuredTimeout, resolveAgent } from "@poe-code/poe-code-config";
 import { computeIngestKey, readCacheEntry, writeCacheEntry } from "./cache.js";
 import { MEMORY_INDEX_RELPATH } from "./paths.js";
 import { reconcile, snapshot } from "./reconcile.js";
 import { computeTokenStats } from "./tokens.js";
 export const INGEST_PROMPT_VERSION = "v1";
-export async function ingest(root, opts) {
+function resolveRunners(overrides) {
+    return {
+        computeIngestKey: overrides?.computeIngestKey ?? computeIngestKey,
+        readCacheEntry: overrides?.readCacheEntry ?? readCacheEntry,
+        writeCacheEntry: overrides?.writeCacheEntry ?? writeCacheEntry,
+        computeTokenStats: overrides?.computeTokenStats ?? computeTokenStats,
+        snapshot: overrides?.snapshot ?? snapshot,
+        reconcile: overrides?.reconcile ?? reconcile
+    };
+}
+export async function ingest(root, opts, runners) {
+    const resolved = resolveRunners(runners);
     const source = await materializeSource(opts.source);
     const indexMdBytes = await fs.readFile(path.join(root, MEMORY_INDEX_RELPATH));
     const configOptions = {
@@ -14,21 +26,21 @@ export async function ingest(root, opts) {
         filePath: path.join(inferRepoRoot(root), "poe-code.json")
     };
     const agentId = (await resolveAgent(configOptions, opts.agent ?? null)) ?? opts.agent ?? "claude-code";
-    const key = computeIngestKey({
+    const key = resolved.computeIngestKey({
         sourceBytes: source.bytes,
         indexMdBytes,
         promptTemplateVersion: INGEST_PROMPT_VERSION,
         agentId
     });
     if (!opts.force && (await cacheEnabled(configOptions))) {
-        const hit = await readCacheEntry(root, key);
+        const hit = await resolved.readCacheEntry(root, key);
         if (hit !== null) {
             return {
                 diff: { created: [], updated: [], deleted: [] },
                 exitCode: 0,
                 durationMs: 0,
                 cacheHit: true,
-                tokens: await computeTokenStats(root)
+                tokens: await resolved.computeTokenStats(root)
             };
         }
     }
@@ -40,29 +52,28 @@ export async function ingest(root, opts) {
             exitCode: 0,
             durationMs: 0,
             cacheHit: false,
-            tokens: await computeTokenStats(root)
+            tokens: await resolved.computeTokenStats(root)
         };
     }
-    const before = await snapshot(root);
+    const before = await resolved.snapshot(root);
     let exitCode = 1;
     let durationMs = 0;
     let timeoutError;
     try {
-        const spawnFn = opts.spawnFn;
-        const result = await runWithTimeout(spawnFn?.(agentId, prompt) ?? Promise.resolve({ exitCode: 0, durationMs: 0 }), opts.timeoutMs ?? (await configuredTimeout(configOptions)));
+        const result = await runWithTimeout(spawn(agentId, { prompt }), opts.timeoutMs ?? (await configuredTimeout(configOptions)));
         exitCode = result.exitCode;
-        durationMs = result.durationMs;
+        durationMs = result.durationMs ?? 0;
     }
     catch (error) {
         timeoutError = error instanceof Error ? error : new Error(String(error));
     }
-    const diff = await reconcile(root, before, "ingest", opts.reason ?? `ingest ${source.label}`);
-    const tokens = await computeTokenStats(root);
+    const diff = await resolved.reconcile(root, before, "ingest", opts.reason ?? `ingest ${source.label}`);
+    const tokens = await resolved.computeTokenStats(root);
     if (timeoutError !== undefined) {
         throw timeoutError;
     }
     if (!opts.noCacheWrite && (await cacheEnabled(configOptions)) && exitCode === 0) {
-        await writeCacheEntry(root, {
+        await resolved.writeCacheEntry(root, {
             key,
             ingestedAt: new Date().toISOString(),
             sourceLabel: source.label,

package/packages/memory/dist/mcp.d.ts

@@ -1,6 +1,8 @@
 import type { Server } from "../../tiny-stdio-mcp-server/dist/index.js";
-import type { McpServerOptions } from "./types.js";
-export declare function startMemoryMcpServer(opts: McpServerOptions): Promise<{
+import type { MemoryHandle } from "./handle.js";
+export declare function startMemoryMcpServer(handle: MemoryHandle, opts: {
+    allowWrites: boolean;
+}): Promise<{
     stop: () => Promise<void>;
     server: Server;
 }>;

package/packages/memory/dist/mcp.js

@@ -1,21 +1,17 @@
 import { createServer, defineSchema } from "tiny-stdio-mcp-server";
-import { appendToPage } from "./write.js";
-import { listPages, readPage } from "./pages.js";
-import { searchMemory } from "./search.js";
-import { statusOf } from "./status.js";
-export async function startMemoryMcpServer(opts) {
+export async function startMemoryMcpServer(handle, opts) {
     const server = createServer({
         name: "poe-code-memory",
         version: "0.0.1"
     });
     server.tool("list_pages", "List memory pages.", defineSchema({}), async () => ({
-        pages: (await listPages(opts.root)).map((page) => ({
+        pages: (await handle.listPages()).map((page) => ({
             rel_path: page.relPath,
             description: page.frontmatter.description ?? ""
         }))
     }));
     server.tool("read_page", "Read a memory page.", defineSchema({ rel_path: { type: "string" } }), async ({ rel_path }) => {
-        const page = await readPage(opts.root, rel_path);
+        const page = await handle.readPage(rel_path);
         return {
             rel_path: page.relPath,
             frontmatter: page.frontmatter,
@@ -27,17 +23,17 @@ export async function startMemoryMcpServer(opts) {
         query: { type: "string" },
         limit: { type: "number", optional: true }
     }), async ({ query, limit }) => {
-        const hits = await searchMemory(opts.root, query);
+        const hits = await handle.searchMemory(query);
         return { hits: typeof limit === "number" ? hits.slice(0, limit) : hits };
     });
-    server.tool("status", "Show memory status.", defineSchema({}), async () => statusOf(opts.root));
+    server.tool("status", "Show memory status.", defineSchema({}), async () => handle.statusOf());
     if (opts.allowWrites) {
         server.tool("append_to_page", "Append content to a memory page.", defineSchema({
             rel_path: { type: "string" },
             content: { type: "string" },
             reason: { type: "string" }
         }), async ({ rel_path, content, reason }) => ({
-            diff: await appendToPage(opts.root, rel_path, content, { reason })
+            diff: await handle.appendToPage(rel_path, content, { reason })
         }));
     }
     return {

package/packages/memory/dist/query.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import path from "node:path";
 import { countTokens } from "tokenfill";
+import { spawn } from "@poe-code/agent-spawn";
 import { resolveAgent } from "@poe-code/poe-code-config";
 import { listPages } from "./pages.js";
 import { MEMORY_INDEX_RELPATH } from "./paths.js";
@@ -21,14 +22,7 @@ export async function queryMemory(root, options) {
     };
     const agentId = (await resolveAgent(configOptions, options.agent ?? null)) ?? options.agent ?? "claude-code";
     const context = await selectQueryContext(root, options.question, options.budget);
-    const spawnFn = options.spawnFn;
-    const result = (await spawnFn?.(agentId, context.prompt)) ?? {
-        answer: "",
-        citations: [],
-        tokensUsed: context.tokensUsed,
-        budget: options.budget,
-        exitCode: 0
-    };
+    const result = (await spawn(agentId, { prompt: context.prompt }));
     return {
         answer: result.answer,
         citations: result.citations,

package/packages/memory/dist/types.d.ts

@@ -70,7 +70,6 @@ export type IngestSource = {
     kind: "url";
     url: string;
 };
-export type SpawnFn<TResult = unknown> = (agent: string, prompt: string) => Promise<TResult>;
 export type IngestOptions = {
     source: IngestSource;
     agent?: string;
@@ -79,14 +78,6 @@ export type IngestOptions = {
     dryRun?: boolean;
     force?: boolean;
     noCacheWrite?: boolean;
-    spawnFn?: SpawnFn;
-};
-export type LintOptions = {
-    fix?: boolean;
-    agent?: string;
-    timeoutMs?: number;
-    dryRun?: boolean;
-    spawnFn?: SpawnFn;
 };
 export type IngestResult = {
     diff: MemoryDiff;
@@ -95,13 +86,6 @@ export type IngestResult = {
     cacheHit: boolean;
     tokens: TokenStats;
 };
-export type LintResult = {
-    diff: MemoryDiff;
-    issues: string[];
-    exitCode: number;
-    durationMs: number;
-    tokens: TokenStats;
-};
 export type IngestCacheKey = string;
 export type IngestCacheEntry = {
     key: IngestCacheKey;
@@ -121,10 +105,6 @@ export type TokenStats = {
     reductionRatio: number;
     missingSources: string[];
 };
-export type McpServerOptions = {
-    root: MemoryRoot;
-    allowWrites: boolean;
-};
 export type MemoryInstallResult = {
     skillInstalled: boolean;
     mcpConfigured: boolean;
@@ -135,7 +115,6 @@ export type QueryOptions = {
     question: string;
     budget: number;
     agent?: string;
-    spawnFn?: SpawnFn;
 };
 export type QueryCitation = {
     relPath: string;

package/packages/tiny-oauth-test-server/dist/cli.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+import { readFileSync, realpathSync } from "node:fs";
+import { parseArgs } from "node:util";
+import { pathToFileURL } from "node:url";
+import { createOAuthTestServer, } from "./index.js";
+function readPackageInfo() {
+    try {
+        const packageJson = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        if (typeof packageJson.name === "string" &&
+            typeof packageJson.version === "string") {
+            return {
+                name: packageJson.name,
+                version: packageJson.version,
+            };
+        }
+    }
+    catch {
+        // Fall through to stable defaults when package.json is unavailable.
+    }
+    return {
+        name: "tiny-oauth-test-server",
+        version: "0.0.0",
+    };
+}
+const packageInfo = readPackageInfo();
+const HELP_TEXT = [
+    "Usage: tiny-oauth-test-server [options]",
+    "",
+    "Options:",
+    "  --port <port>                               Port to listen on (default: 0, ephemeral)",
+    "  --hostname <hostname>                       Hostname to bind to (default: 127.0.0.1)",
+    "  --issuer <url>                              Issuer URL to publish in metadata and tokens",
+    "  --ttl-seconds <seconds>                     Access token TTL in seconds (default: 60)",
+    "  --auto-approve                              Auto-approve every authorization request",
+    "  --static-client <client_id:redirect_uri[,redirect_uri...]>",
+    "                                             Register a repeatable static client",
+    "  -h, --help                                  Show this help message",
+].join("\n");
+function parsePort(value) {
+    if (value === undefined) {
+        return 0;
+    }
+    const port = Number(value);
+    if (!Number.isInteger(port) || port < 0 || port > 65535) {
+        throw new Error("--port must be an integer between 0 and 65535.");
+    }
+    return port;
+}
+function parsePositiveInteger(value, flagName) {
+    if (value === undefined) {
+        return 60;
+    }
+    const parsed = Number(value);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${flagName} must be a positive integer.`);
+    }
+    return parsed;
+}
+function parseIssuer(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    try {
+        return new URL(value).toString();
+    }
+    catch {
+        throw new Error("--issuer must be an absolute URL.");
+    }
+}
+function parseStaticClientEntry(value) {
+    const separatorIndex = value.indexOf(":");
+    if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
+        throw new Error("--static-client must use client_id:redirect_uri[,redirect_uri...] format.");
+    }
+    const clientId = value.slice(0, separatorIndex);
+    const redirectUris = value
+        .slice(separatorIndex + 1)
+        .split(",")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+    if (redirectUris.length === 0) {
+        throw new Error("--static-client must include at least one redirect_uri.");
+    }
+    return {
+        clientId,
+        redirectUris,
+    };
+}
+function parseCliOptions(args) {
+    const { values } = parseArgs({
+        args,
+        strict: true,
+        allowPositionals: false,
+        options: {
+            port: { type: "string" },
+            hostname: { type: "string" },
+            issuer: { type: "string" },
+            "ttl-seconds": { type: "string" },
+            "auto-approve": { type: "boolean" },
+            "static-client": { type: "string", multiple: true },
+            help: { type: "boolean", short: "h" },
+        },
+    });
+    return {
+        help: values.help ?? false,
+        port: parsePort(values.port),
+        hostname: values.hostname ?? "127.0.0.1",
+        issuer: parseIssuer(values.issuer),
+        ttlSeconds: parsePositiveInteger(values["ttl-seconds"], "--ttl-seconds"),
+        autoApprove: values["auto-approve"] ?? false,
+        staticClients: (values["static-client"] ?? []).map(parseStaticClientEntry),
+    };
+}
+function formatCurlInvocation(baseUrl) {
+    return [
+        "curl -sS -X POST",
+        `${baseUrl}/testing/issue-token`,
+        "-H 'Content-Type: application/json'",
+        "-d '{\"client_id\":\"demo-client\",\"resource\":\"https://resource.example.com/mcp\",\"scopes\":[\"mcp.read\"]}'",
+    ].join(" ");
+}
+function waitForShutdown(shutdown) {
+    return new Promise((resolve, reject) => {
+        const onSignal = () => {
+            process.off("SIGINT", onSignal);
+            process.off("SIGTERM", onSignal);
+            void shutdown().then(resolve, reject);
+        };
+        process.once("SIGINT", onSignal);
+        process.once("SIGTERM", onSignal);
+    });
+}
+export function isCliInvocation(argv, moduleUrl, realpath = realpathSync) {
+    const entry = argv.at(1);
+    if (typeof entry !== "string") {
+        return false;
+    }
+    const candidates = [pathToFileURL(entry).href];
+    try {
+        candidates.push(pathToFileURL(realpath(entry)).href);
+    }
+    catch {
+        // Ignore resolution failures and keep the direct path candidate.
+    }
+    return candidates.includes(moduleUrl);
+}
+export async function runCli(args = process.argv.slice(2), dependencies = {}) {
+    const stdout = dependencies.stdout ?? process.stdout;
+    const stderr = dependencies.stderr ?? process.stderr;
+    let parsed;
+    try {
+        parsed = parseCliOptions(args);
+    }
+    catch (error) {
+        stderr.write(`${error instanceof Error ? error.message : String(error)}\n\n${HELP_TEXT}\n`);
+        return 1;
+    }
+    if (parsed.help) {
+        stdout.write(`${HELP_TEXT}\n`);
+        return 0;
+    }
+    const listenOptions = {
+        port: parsed.port,
+        hostname: parsed.hostname,
+    };
+    const server = createOAuthTestServer({
+        issuer: parsed.issuer,
+        defaultTokenTtlSeconds: parsed.ttlSeconds,
+        staticClients: parsed.staticClients,
+        defaultAuthorization: {
+            autoApprove: parsed.autoApprove,
+        },
+    });
+    const handle = await server.listen(listenOptions);
+    const metadataUrl = `${server.issuer}/.well-known/oauth-authorization-server`;
+    stdout.write(`${packageInfo.name} ${packageInfo.version}\n`);
+    stdout.write(`Bound URL: ${handle.url}\n`);
+    stdout.write(`Issuer: ${server.issuer}\n`);
+    stdout.write(`PRM metadata URL: ${metadataUrl}\n`);
+    stdout.write(`Issue token curl: ${formatCurlInvocation(handle.url)}\n`);
+    await (dependencies.waitForShutdown ?? waitForShutdown)(handle.close);
+    return 0;
+}
+if (isCliInvocation(process.argv, import.meta.url)) {
+    void runCli().then((exitCode) => {
+        process.exitCode = exitCode;
+    }, (error) => {
+        process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+        process.exitCode = 1;
+    });
+}

package/packages/tiny-stdio-mcp-server/dist/server.js

@@ -76,7 +76,9 @@ export function createServer(options) {
             }
             try {
                 const handlerResult = await tool.handler(toolArgs);
-                const result = { content: toContentBlocks(handlerResult) };
+                const result = isCallToolResult(handlerResult)
+                    ? handlerResult
+                    : { content: toContentBlocks(handlerResult) };
                 return { result };
             }
             catch (err) {
@@ -224,3 +226,9 @@ export function createServer(options) {
     };
     return server;
 }
+function isCallToolResult(value) {
+    if (typeof value !== "object" || value === null || !("content" in value)) {
+        return false;
+    }
+    return Array.isArray(value.content);
+}

package/packages/tiny-stdio-mcp-server/dist/types.d.ts

@@ -92,7 +92,7 @@ export interface ServerOptions {
     version: string;
 }
 import type { ToolReturn } from "./content/index.js";
-export type ToolHandler<T = Record<string, unknown>> = (args: T) => Promise<ToolReturn> | ToolReturn;
+export type ToolHandler<T = Record<string, unknown>> = (args: T) => Promise<ToolReturn | CallToolResult> | ToolReturn | CallToolResult;
 export interface ToolDefinition<T = Record<string, unknown>> {
     name: string;
     description: string;