@rien7/agent-center-host 0.0.0-stage → 0.1.1

package/dist/login.js

@@ -0,0 +1,103 @@
+/**
+ * `agent-host login`: the same RFC 8628 device flow the apps use
+ * (packages/data/src/device-login.ts): register a public client, ask for a device code
+ * with scope `agent:host`, show the 4-digit pairing code, poll /oauth/token until the
+ * owner approves the request in the app, then store the tokens.
+ */
+import { deviceGrantType } from "./credentials.js";
+export function normalizeServer(server) {
+    const url = new URL(server.trim());
+    if (url.username ||
+        url.password ||
+        url.search ||
+        url.hash ||
+        url.pathname !== "/" ||
+        (url.protocol !== "https:" &&
+            !(url.protocol === "http:" &&
+                ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname))))
+        throw new Error("Use an HTTPS server origin (HTTP only for localhost), without a path");
+    return url.origin;
+}
+async function post(fetcher, url, body, type = "application/x-www-form-urlencoded") {
+    const response = await fetcher(url, {
+        method: "POST",
+        headers: { "content-type": type },
+        body,
+    });
+    const data = (await response.json().catch(() => ({})));
+    return { response, data };
+}
+export async function deviceLogin(o) {
+    const fetcher = o.fetch ?? fetch;
+    const sleep = o.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const base = normalizeServer(o.server);
+    const register = async () => {
+        const { response, data } = await post(fetcher, `${base}/oauth/register`, JSON.stringify({
+            client_name: o.clientName,
+            grant_types: [deviceGrantType, "refresh_token"],
+            token_endpoint_auth_method: "none",
+        }), "application/json");
+        if (!response.ok || typeof data.client_id !== "string")
+            throw new Error(`Client registration failed: ${String(data.error_description ?? response.status)}`);
+        return data.client_id;
+    };
+    let clientId = o.clientId ?? (await register());
+    const authorize = () => post(fetcher, `${base}/oauth/device_authorization`, new URLSearchParams({
+        client_id: clientId,
+        scope: o.scope ?? "agent:host",
+    }).toString());
+    let { response, data } = await authorize();
+    // The server may have dropped a client that never obtained a grant.
+    if (o.clientId &&
+        !response.ok &&
+        ["invalid_client", "unauthorized_client"].includes(String(data.error))) {
+        clientId = await register();
+        ({ response, data } = await authorize());
+    }
+    if (!response.ok || typeof data.device_code !== "string")
+        throw new Error(`Login request failed: ${String(data.error_description ?? data.error ?? response.status)}`);
+    o.prompt({
+        userCode: String(data.user_code),
+        verificationUri: String(data.verification_uri),
+    });
+    let interval = Math.max(5, Number(data.interval ?? 5)) * 1000;
+    const expires = Date.now() + Number(data.expires_in ?? 600) * 1000;
+    for (;;) {
+        await sleep(interval);
+        if (o.signal?.aborted)
+            throw new Error("Login cancelled");
+        if (Date.now() >= expires)
+            throw new Error("The login request expired; run agent-host login again");
+        let result;
+        try {
+            result = await post(fetcher, `${base}/oauth/token`, new URLSearchParams({
+                client_id: clientId,
+                grant_type: deviceGrantType,
+                device_code: data.device_code,
+            }).toString());
+        }
+        catch {
+            interval = Math.min(60_000, interval * 2);
+            continue;
+        }
+        const tokens = result.data;
+        if (result.response.ok) {
+            if (typeof tokens.access_token !== "string" ||
+                typeof tokens.refresh_token !== "string")
+                throw new Error("The server returned no usable tokens");
+            return {
+                server: base,
+                clientId,
+                accessToken: tokens.access_token,
+                refreshToken: tokens.refresh_token,
+                accessExpiresAt: Date.now() + Number(tokens.expires_in ?? 3600) * 1000,
+            };
+        }
+        if (tokens.error === "slow_down")
+            interval += 5000;
+        else if (tokens.error !== "authorization_pending")
+            throw new Error(tokens.error === "access_denied"
+                ? "The login request was denied"
+                : `Login failed: ${String(tokens.error_description ?? tokens.error)}`);
+    }
+}

package/dist/memory.js

@@ -0,0 +1,163 @@
+/**
+ * An agent's memory files: `<workdir>/agents/<agentId>/memory/` on the host (the
+ * runtime's file tools edit them), mirrored to Center (`agent.memory_file.*`, host token).
+ *
+ * - start: pull the server's files (the server wins), push local-only files, and write a
+ *   template MEMORY.md for a new agent.
+ * - after each turn and on fs.watch (debounced): push changed files with ifVersion; on a
+ *   conflict the server's copy overwrites the local one (logged).
+ *
+ * Deleting a file locally doesn't delete it on Center (there is no delete op yet); the
+ * next start brings it back.
+ */
+import { createHash } from "node:crypto";
+import { watch } from "node:fs";
+import { mkdir, readdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join, relative, sep } from "node:path";
+import { CoreError } from "./core-client.js";
+export const memoryIndex = "MEMORY.md";
+const maxContent = 200_000;
+/** MEMORY.md injected into each turn, at most this many characters. */
+export const memoryPromptChars = 8_000;
+export const memoryTemplate = (name) => `# ${name} 的记忆
+
+这是长期记忆的索引，每轮对话开头都会读到。保持简短：每条一行，细节写进 notes/ 下的文件并在这里链接。
+
+## 关于用户
+
+## 约定与偏好
+
+## 笔记索引
+`;
+const hash = (text) => createHash("sha256").update(text).digest("hex");
+const posix = (path) => path.split(sep).join("/");
+export class MemorySync {
+    dir;
+    client;
+    agentId;
+    agentName;
+    updatedBy;
+    log;
+    /** path → what the server has (version, content hash). */
+    known = new Map();
+    watcher = null;
+    timer = null;
+    chain = Promise.resolve();
+    constructor(options) {
+        this.client = options.client;
+        this.agentId = options.agentId;
+        this.agentName = options.agentName;
+        this.dir = join(options.agentDir, "memory");
+        this.updatedBy = options.updatedBy ?? "agent-host";
+        this.log = options.log ?? (() => { });
+    }
+    /** Pull, push local-only files, create the template; then watch. */
+    async start() {
+        await mkdir(join(this.dir, "notes"), { recursive: true });
+        const remote = await this.client.memoryList(this.agentId);
+        for (const info of remote) {
+            const file = await this.client.memoryGet(this.agentId, info.path);
+            await this.writeLocal(file.path, file.content);
+            this.known.set(file.path, {
+                version: file.version,
+                hash: hash(file.content),
+            });
+        }
+        const local = await this.localFiles();
+        if (!remote.length && !local.includes(memoryIndex))
+            await this.writeLocal(memoryIndex, memoryTemplate(this.agentName));
+        await this.sync();
+        try {
+            this.watcher = watch(this.dir, { recursive: true }, () => this.soon());
+            this.watcher.on("error", () => { });
+        }
+        catch (error) {
+            this.log(`memory watch unavailable (${error.message}); syncing after turns only`);
+        }
+    }
+    stop() {
+        this.watcher?.close();
+        this.watcher = null;
+        if (this.timer)
+            clearTimeout(this.timer);
+        return this.sync();
+    }
+    /** MEMORY.md for the prompt (clipped), or null when empty. */
+    async index() {
+        const text = await readFile(join(this.dir, memoryIndex), "utf8").catch(() => "");
+        if (!text.trim())
+            return null;
+        return text.length > memoryPromptChars
+            ? `${text.slice(0, memoryPromptChars)}\n…（MEMORY.md 过长，后面被截掉了；请精简它）`
+            : text;
+    }
+    soon() {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            this.timer = null;
+            this.sync();
+        }, 500);
+    }
+    /** Push every local file that differs from what the server has. Serialized. */
+    sync() {
+        this.chain = this.chain
+            .then(() => this.pushChanged())
+            .catch((error) => this.log(`memory sync failed (${error.message})`));
+        return this.chain;
+    }
+    async localFiles() {
+        const entries = await readdir(this.dir, {
+            recursive: true,
+            withFileTypes: true,
+        }).catch(() => []);
+        return entries
+            .filter((e) => e.isFile() && e.name.endsWith(".md"))
+            .map((e) => posix(relative(this.dir, join(e.parentPath ?? this.dir, e.name))))
+            .filter((p) => !p.startsWith(".") && !p.includes("/."));
+    }
+    async pushChanged() {
+        for (const path of await this.localFiles()) {
+            const content = await readFile(join(this.dir, path), "utf8").catch(() => null);
+            if (content === null)
+                continue;
+            const known = this.known.get(path);
+            if (known?.hash === hash(content))
+                continue;
+            if (content.length > maxContent) {
+                this.log(`memory ${path} is over ${maxContent} characters; not synced`);
+                continue;
+            }
+            try {
+                const saved = await this.client.memoryPut({
+                    agentId: this.agentId,
+                    path,
+                    content,
+                    ...(known ? { ifVersion: known.version } : {}),
+                    updatedBy: this.updatedBy,
+                });
+                this.known.set(path, { version: saved.version, hash: hash(content) });
+            }
+            catch (error) {
+                if (error instanceof CoreError && error.status === 409) {
+                    const server = await this.client.memoryGet(this.agentId, path);
+                    await this.writeLocal(path, server.content);
+                    this.known.set(path, {
+                        version: server.version,
+                        hash: hash(server.content),
+                    });
+                    this.log(`memory ${path}: Center has a newer version (${server.version}); local edit replaced`);
+                }
+                else
+                    throw error;
+            }
+        }
+    }
+    async writeLocal(path, content) {
+        const target = join(this.dir, path);
+        await mkdir(dirname(target), { recursive: true });
+        const temporary = `${target}.${process.pid}.tmp`;
+        await writeFile(temporary, content);
+        await rename(temporary, target);
+    }
+}