@cjhyy/code-shell-core 0.7.0 → 0.8.0

package/dist/services/oauth.js

@@ -1,81 +1,212 @@
-/**
- * OAuth service — OAuth 2.0 authorization code flow with PKCE.
- *
- * Supports browser-based login flow for API authentication.
- */
+/** OAuth 2.0 authorization-code + PKCE primitives for host applications. */
+import { createHash, randomBytes } from "node:crypto";
 import { createServer } from "node:http";
-import { randomBytes, createHash } from "node:crypto";
-import { execFile } from "node:child_process";
-import { browserOpenCommand } from "./browser-open.js";
+import { mergeOAuthTokenResponse } from "../credentials/oauth.js";
+const OAUTH_REDIRECT_STATUSES = new Set([301, 302, 303, 307, 308]);
+function normalizedHostname(hostname) {
+    return hostname
+        .replace(/^\[|\]$/g, "")
+        .replace(/\.$/, "")
+        .toLowerCase();
+}
+function ipv4Octets(hostname) {
+    const parts = normalizedHostname(hostname).split(".");
+    if (parts.length !== 4 || parts.some((part) => !/^\d{1,3}$/.test(part)))
+        return undefined;
+    const octets = parts.map(Number);
+    return octets.every((part) => part >= 0 && part <= 255) ? octets : undefined;
+}
+function isLoopbackHostname(hostname) {
+    const host = normalizedHostname(hostname);
+    const octets = ipv4Octets(host);
+    return host === "localhost" || host === "::1" || Boolean(octets && octets[0] === 127);
+}
+function isPrivateNetworkHostname(hostname) {
+    const host = normalizedHostname(hostname);
+    const octets = ipv4Octets(host);
+    if (octets) {
+        const [a, b] = octets;
+        return (a === 0 ||
+            a === 10 ||
+            (a === 100 && b >= 64 && b <= 127) ||
+            (a === 169 && b === 254) ||
+            (a === 172 && b >= 16 && b <= 31) ||
+            (a === 192 && b === 168) ||
+            (a === 198 && (b === 18 || b === 19)));
+    }
+    if (!host.includes(":"))
+        return false;
+    return host === "::" || host.startsWith("fc") || host.startsWith("fd") || /^fe[89ab]/.test(host);
+}
+function validateOAuthRequestUrl(url) {
+    if (url.username || url.password)
+        throw new Error("OAuth endpoint must not include credentials");
+    const loopback = isLoopbackHostname(url.hostname);
+    if (url.protocol !== "https:" && !(url.protocol === "http:" && loopback)) {
+        throw new Error("OAuth endpoint must use HTTPS (HTTP is allowed only for localhost)");
+    }
+    if (!loopback && isPrivateNetworkHostname(url.hostname)) {
+        throw new Error("OAuth endpoint must not target a private network address");
+    }
+}
 /**
- * Generate PKCE code verifier and challenge.
+ * Wrap fetch with OAuth-specific redirect handling. Every hop is validated;
+ * POST/Authorization requests never cross origins, so authorization codes,
+ * verifiers, refresh tokens, client secrets, and revocation tokens cannot be
+ * forwarded by an upstream 30x response.
  */
-function generatePKCE() {
+export function createHardenedOAuthFetch(baseFetch = fetch, options = {}) {
+    const maxRedirects = Math.max(0, Math.min(10, options.maxRedirects ?? 5));
+    return (async (input, init) => {
+        // Bun and Node's undici declarations currently expose incompatible global
+        // Request overloads even though both accept the standard fetch input at
+        // runtime. Keep that ambient type conflict contained at this boundary.
+        const initial = new Request(input, init);
+        let currentUrl = new URL(initial.url);
+        const initialLoopback = isLoopbackHostname(currentUrl.hostname);
+        let method = initial.method.toUpperCase();
+        let headers = new Headers(initial.headers);
+        let body = method === "GET" || method === "HEAD"
+            ? undefined
+            : new Uint8Array(await initial.clone().arrayBuffer());
+        const secretBearing = (method !== "GET" && method !== "HEAD") || headers.has("authorization");
+        for (let redirectCount = 0;; redirectCount++) {
+            validateOAuthRequestUrl(currentUrl);
+            const request = new Request(currentUrl.toString(), {
+                method,
+                headers,
+                body: body ? body.slice() : undefined,
+                redirect: "manual",
+                signal: initial.signal,
+            });
+            const response = await baseFetch(request);
+            if (!OAUTH_REDIRECT_STATUSES.has(response.status))
+                return response;
+            const location = response.headers.get("location");
+            if (!location)
+                return response;
+            if (redirectCount >= maxRedirects)
+                throw new Error("OAuth redirect limit exceeded");
+            const nextUrl = new URL(location, currentUrl);
+            validateOAuthRequestUrl(nextUrl);
+            if (!initialLoopback && isLoopbackHostname(nextUrl.hostname)) {
+                throw new Error("OAuth redirect to a local network target is not allowed");
+            }
+            if (secretBearing && nextUrl.origin !== currentUrl.origin) {
+                throw new Error("OAuth secret-bearing request refused a cross-origin redirect");
+            }
+            if (response.status === 303 ||
+                ((response.status === 301 || response.status === 302) && method === "POST")) {
+                method = "GET";
+                body = undefined;
+                headers = new Headers(headers);
+                headers.delete("content-type");
+                headers.delete("content-length");
+            }
+            currentUrl = nextUrl;
+        }
+    });
+}
+export function generatePKCE() {
     const verifier = randomBytes(32).toString("base64url");
     const challenge = createHash("sha256").update(verifier).digest("base64url");
     return { verifier, challenge };
 }
-/**
- * Open a URL in the system browser.
- */
-function openBrowser(url) {
-    // execFile with an argv array — no shell, so the URL can't be interpreted.
-    const { cmd, args } = browserOpenCommand(process.platform, url);
-    execFile(cmd, args, () => { });
+function tokensFromSecret(secret) {
+    return {
+        accessToken: secret.accessToken,
+        refreshToken: secret.refreshToken,
+        expiresAt: secret.expiresAt ? Date.parse(secret.expiresAt) : undefined,
+        tokenType: secret.tokenType ?? "Bearer",
+        scope: secret.scope,
+    };
+}
+function callbackSettings(config, options) {
+    const host = options.callbackHost ?? "127.0.0.1";
+    if (!config.redirectUri) {
+        return { host, port: options.callbackPort ?? 0, path: "/callback" };
+    }
+    const redirect = new URL(config.redirectUri);
+    if (redirect.protocol !== "http:" ||
+        (redirect.hostname !== "127.0.0.1" && redirect.hostname !== "localhost")) {
+        throw new Error("OAuth redirectUri must be an HTTP loopback URL");
+    }
+    const port = options.callbackPort ?? Number(redirect.port || "80");
+    return {
+        host,
+        port,
+        path: redirect.pathname || "/callback",
+        fixedRedirect: options.callbackPort === undefined ? redirect.toString() : undefined,
+    };
 }
 /**
- * Run the OAuth authorization code flow.
- * Opens a browser for user login and waits for the callback.
+ * Run an OAuth authorization-code flow. The host owns browser launching and
+ * injects `openExternal`; core only listens on an ephemeral loopback port.
  */
-export async function authorize(config) {
+export async function authorize(config, options = {}) {
+    if (options.signal?.aborted)
+        throw new Error("OAuth authorization aborted");
+    const callback = callbackSettings(config, options);
     const { verifier, challenge } = generatePKCE();
     const state = randomBytes(16).toString("hex");
-    const port = 18910 + Math.floor(Math.random() * 100);
-    const redirectUri = config.redirectUri ?? `http://localhost:${port}/callback`;
-    // Build authorization URL
-    const params = new URLSearchParams({
-        response_type: "code",
-        client_id: config.clientId,
-        redirect_uri: redirectUri,
-        state,
-        code_challenge: challenge,
-        code_challenge_method: "S256",
-    });
-    if (config.scopes?.length) {
-        params.set("scope", config.scopes.join(" "));
-    }
-    const authUrl = `${config.authorizationEndpoint}?${params.toString()}`;
+    const fetchFn = createHardenedOAuthFetch(options.fetch ?? fetch);
+    const openExternal = options.openExternal;
+    if (!openExternal)
+        throw new Error("OAuth authorize requires an openExternal host callback");
     return new Promise((resolve, reject) => {
-        const timeout = setTimeout(() => {
-            server.close();
-            reject(new Error("OAuth authorization timed out (120s)"));
-        }, 120_000);
+        let settled = false;
+        let timer;
+        let redirectUri = "";
+        const cleanup = () => {
+            if (timer)
+                clearTimeout(timer);
+            options.signal?.removeEventListener("abort", onAbort);
+            if (server.listening)
+                server.close();
+        };
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(err instanceof Error ? err : new Error(String(err)));
+        };
+        const succeed = (tokens) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(tokens);
+        };
+        const onAbort = () => fail(new Error("OAuth authorization aborted"));
         const server = createServer(async (req, res) => {
-            if (!req.url?.startsWith("/callback")) {
+            const requestUrl = new URL(req.url ?? "/", redirectUri || "http://127.0.0.1");
+            if (requestUrl.pathname !== callback.path) {
                 res.writeHead(404);
                 res.end("Not found");
                 return;
             }
-            const url = new URL(req.url, `http://localhost:${port}`);
-            const code = url.searchParams.get("code");
-            const returnedState = url.searchParams.get("state");
-            const error = url.searchParams.get("error");
-            clearTimeout(timeout);
-            if (error) {
-                res.writeHead(200, { "Content-Type": "text/html" });
-                res.end("<html><body><h1>Authorization failed</h1><p>You can close this window.</p></body></html>");
-                server.close();
-                reject(new Error(`OAuth error: ${error}`));
+            const returnedState = requestUrl.searchParams.get("state");
+            const code = requestUrl.searchParams.get("code");
+            const oauthError = requestUrl.searchParams.get("error");
+            if (returnedState !== state) {
+                res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+                res.end("<h1>Invalid OAuth callback</h1><p>You can close this window.</p>");
+                fail(new Error("Invalid OAuth callback: state mismatch"));
                 return;
             }
-            if (!code || returnedState !== state) {
-                res.writeHead(400, { "Content-Type": "text/html" });
-                res.end("<html><body><h1>Invalid callback</h1></body></html>");
-                server.close();
-                reject(new Error("Invalid OAuth callback: missing code or state mismatch"));
+            if (oauthError) {
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                res.end("<h1>Authorization was not completed</h1><p>You can close this window.</p>");
+                fail(new Error(oauthError === "access_denied" ? "OAuth access denied" : "OAuth failed"));
+                return;
+            }
+            if (!code) {
+                res.writeHead(400, { "Content-Type": "text/html; charset=utf-8" });
+                res.end("<h1>Invalid OAuth callback</h1><p>You can close this window.</p>");
+                fail(new Error("Invalid OAuth callback: missing code"));
                 return;
             }
-            // Exchange code for tokens
             try {
                 const tokenParams = new URLSearchParams({
                     grant_type: "authorization_code",
@@ -84,68 +215,75 @@ export async function authorize(config) {
                     client_id: config.clientId,
                     code_verifier: verifier,
                 });
-                const tokenRes = await fetch(config.tokenEndpoint, {
+                if (config.clientSecret)
+                    tokenParams.set("client_secret", config.clientSecret);
+                if (config.resource)
+                    tokenParams.set("resource", config.resource);
+                const tokenRes = await fetchFn(config.tokenEndpoint, {
                     method: "POST",
                     headers: { "Content-Type": "application/x-www-form-urlencoded" },
                     body: tokenParams.toString(),
+                    signal: options.signal,
                 });
                 if (!tokenRes.ok) {
-                    throw new Error(`Token exchange failed: ${tokenRes.status} ${await tokenRes.text()}`);
+                    throw new Error(`OAuth token exchange failed (${tokenRes.status})`);
                 }
-                const data = (await tokenRes.json());
-                const tokens = {
-                    accessToken: data.access_token,
-                    refreshToken: data.refresh_token,
-                    expiresAt: data.expires_in
-                        ? Date.now() + data.expires_in * 1000
-                        : undefined,
-                    tokenType: data.token_type ?? "Bearer",
-                };
-                res.writeHead(200, { "Content-Type": "text/html" });
-                res.end("<html><body><h1>Authorization successful!</h1><p>You can close this window.</p></body></html>");
-                server.close();
-                resolve(tokens);
+                const secret = mergeOAuthTokenResponse(undefined, (await tokenRes.json()));
+                res.writeHead(200, { "Content-Type": "text/html; charset=utf-8" });
+                res.end("<h1>Authorization successful</h1><p>You can close this window.</p>");
+                succeed(tokensFromSecret(secret));
             }
             catch (err) {
-                res.writeHead(500, { "Content-Type": "text/html" });
-                res.end("<html><body><h1>Token exchange failed</h1></body></html>");
-                server.close();
-                reject(err);
+                res.writeHead(500, { "Content-Type": "text/html; charset=utf-8" });
+                res.end("<h1>Token exchange failed</h1><p>You can close this window.</p>");
+                fail(err);
             }
         });
-        server.listen(port, () => {
-            openBrowser(authUrl);
-        });
-        server.on("error", (err) => {
-            clearTimeout(timeout);
-            reject(new Error(`OAuth server error: ${err.message}`));
+        options.signal?.addEventListener("abort", onAbort, { once: true });
+        server.once("error", (err) => fail(new Error(`OAuth callback server failed: ${err.message}`)));
+        server.listen(callback.port, callback.host, () => {
+            const address = server.address();
+            if (!address || typeof address === "string") {
+                fail(new Error("OAuth callback server did not expose a loopback port"));
+                return;
+            }
+            redirectUri =
+                callback.fixedRedirect ?? `http://${callback.host}:${address.port}${callback.path}`;
+            const authUrl = new URL(config.authorizationEndpoint);
+            authUrl.searchParams.set("response_type", "code");
+            authUrl.searchParams.set("client_id", config.clientId);
+            authUrl.searchParams.set("redirect_uri", redirectUri);
+            authUrl.searchParams.set("state", state);
+            authUrl.searchParams.set("code_challenge", challenge);
+            authUrl.searchParams.set("code_challenge_method", "S256");
+            if (config.scopes?.length)
+                authUrl.searchParams.set("scope", config.scopes.join(" "));
+            if (config.resource)
+                authUrl.searchParams.set("resource", config.resource);
+            timer = setTimeout(() => fail(new Error("OAuth authorization timed out")), options.timeoutMs ?? 120_000);
+            Promise.resolve(openExternal(authUrl.toString())).catch(fail);
         });
     });
 }
-/**
- * Refresh an access token using a refresh token.
- */
-export async function refreshToken(config, refreshTokenValue) {
+export async function refreshToken(config, refreshTokenValue, options = {}) {
     const params = new URLSearchParams({
         grant_type: "refresh_token",
         client_id: config.clientId,
         refresh_token: refreshTokenValue,
     });
-    const res = await fetch(config.tokenEndpoint, {
+    if (config.clientSecret)
+        params.set("client_secret", config.clientSecret);
+    if (config.scopes?.length)
+        params.set("scope", config.scopes.join(" "));
+    if (config.resource)
+        params.set("resource", config.resource);
+    const res = await createHardenedOAuthFetch(options.fetch ?? fetch)(config.tokenEndpoint, {
         method: "POST",
         headers: { "Content-Type": "application/x-www-form-urlencoded" },
         body: params.toString(),
     });
-    if (!res.ok) {
-        throw new Error(`Token refresh failed: ${res.status}`);
-    }
-    const data = (await res.json());
-    return {
-        accessToken: data.access_token,
-        refreshToken: data.refresh_token ?? refreshTokenValue,
-        expiresAt: data.expires_in
-            ? Date.now() + data.expires_in * 1000
-            : undefined,
-        tokenType: data.token_type ?? "Bearer",
-    };
+    if (!res.ok)
+        throw new Error(`OAuth token refresh failed (${res.status})`);
+    const secret = mergeOAuthTokenResponse({ accessToken: "replaced", refreshToken: refreshTokenValue }, (await res.json()), { now: options.now });
+    return tokensFromSecret(secret);
 }

package/dist/services/session-memory.d.ts

@@ -15,19 +15,19 @@ export interface SessionMemoryEntry {
 /**
  * Save a session memory entry.
  */
-export declare function saveSessionMemory(entry: SessionMemoryEntry): void;
+export declare function saveSessionMemory(entry: SessionMemoryEntry, baseDir?: string): void;
 /**
  * Load a session memory by session ID.
  */
-export declare function loadSessionMemory(sessionId: string): SessionMemoryEntry | null;
+export declare function loadSessionMemory(sessionId: string, baseDir?: string): SessionMemoryEntry | null;
 /**
  * List all session memories, most recent first.
  */
-export declare function listSessionMemories(limit?: number): SessionMemoryEntry[];
+export declare function listSessionMemories(limit?: number, baseDir?: string): SessionMemoryEntry[];
 /**
  * Search session memories by keyword.
  */
-export declare function searchSessionMemories(query: string): SessionMemoryEntry[];
+export declare function searchSessionMemories(query: string, baseDir?: string): SessionMemoryEntry[];
 /**
  * Build a prompt for extracting session memory from a conversation.
  */

package/dist/services/session-memory.js

@@ -11,14 +11,17 @@ import { sortSessionMemoriesByRecency } from "./session-memory-sort.js";
 // Resolve per-call (NOT a module const): userHome() reads $HOME live, so a
 // relocated/test HOME redirects writes instead of pinning the real ~/.code-shell
 // at import time (bun freezes a module-level homedir() and never re-reads it).
-function memoryDir() {
-    return join(userHome(), ".code-shell", "session-memories");
+// `baseDir` is the explicit injection point (the `~/.code-shell`-equivalent
+// root): when provided it wins over $HOME resolution — identity-scoped server
+// deployments pass their per-user data root here.
+function memoryDir(baseDir) {
+    return join(baseDir ?? join(userHome(), ".code-shell"), "session-memories");
 }
 /**
  * Save a session memory entry.
  */
-export function saveSessionMemory(entry) {
-    const dir = memoryDir();
+export function saveSessionMemory(entry, baseDir) {
+    const dir = memoryDir(baseDir);
     mkdirSync(dir, { recursive: true });
     const file = join(dir, `${entry.sessionId}.json`);
     writeFileSync(file, JSON.stringify(entry, null, 2), "utf-8");
@@ -26,8 +29,8 @@ export function saveSessionMemory(entry) {
 /**
  * Load a session memory by session ID.
  */
-export function loadSessionMemory(sessionId) {
-    const file = join(memoryDir(), `${sessionId}.json`);
+export function loadSessionMemory(sessionId, baseDir) {
+    const file = join(memoryDir(baseDir), `${sessionId}.json`);
     if (!existsSync(file))
         return null;
     try {
@@ -40,8 +43,8 @@ export function loadSessionMemory(sessionId) {
 /**
  * List all session memories, most recent first.
  */
-export function listSessionMemories(limit = 50) {
-    const dir = memoryDir();
+export function listSessionMemories(limit = 50, baseDir) {
+    const dir = memoryDir(baseDir);
     if (!existsSync(dir))
         return [];
     // Read all entries, then order by createdAt (not by filename — the filename
@@ -63,8 +66,8 @@ export function listSessionMemories(limit = 50) {
 /**
  * Search session memories by keyword.
  */
-export function searchSessionMemories(query) {
-    const all = listSessionMemories(200);
+export function searchSessionMemories(query, baseDir) {
+    const all = listSessionMemories(200, baseDir);
     const q = query.toLowerCase();
     return all.filter((m) => m.summary.toLowerCase().includes(q) ||
         m.keyTopics.some((t) => t.toLowerCase().includes(q)) ||

package/dist/session/memory.d.ts

@@ -215,20 +215,21 @@ export declare class MemoryManager {
         now?: number;
     }): string;
     /**
-     * Two-layer injection index (用户拍板). Merges GLOBAL (cross-project
-     * experience) + PROJECT (this repo's facts) memories into a compact index —
-     * one line per entry, name + description only, NO body. The model reads a
-     * specific entry's full content on demand via MemoryRead (which records a
-     * recall → drives TTL + UI visibility).
+     * Three-layer injection index (用户拍板). Merges GLOBAL (cross-project
+     * experience) + DIGITAL-HUMAN (portable profile experience) + PROJECT
+     * (this repo's facts) memories into a compact index — one line per entry,
+     * name + description only, NO body.
      *
      * This is what fixes "global memory never shows up": global memories are now
      * injected alongside project ones, every session, regardless of cwd.
      *
-     * Static because it must construct two managers (global = no projectDir,
-     * project = with projectDir). `projectDir` undefined → only global is shown.
+     * Static because it must construct the managers for each configured layer.
+     * `projectDir` undefined → no project layer; `profileDir` undefined → no
+     * digital-human layer.
      */
     static buildInjectionIndex(opts: {
         projectDir?: string;
+        profileDir?: string;
         baseDir?: string;
         maxAgeDays?: number;
         now?: number;
@@ -253,6 +254,24 @@ export declare class MemoryManager {
      * O(N²) re-read of every memory file on every save.
      */
     private ensureIndexCache;
+    /**
+     * Rewrite MEMORY.md from the CURRENT set of memory files on disk, under a
+     * cross-process lock.
+     *
+     * The in-memory `indexCache` is a per-instance optimisation, and several
+     * managers exist for the same directory (desktop main, agent worker, TUI, a
+     * second desktop instance). Writing the cache out verbatim meant a stale
+     * snapshot clobbered whatever another writer had added:
+     *
+     *   A saves a → B loads {a}, saves b → A still holds {a}, saves c
+     *   → files a, b, c all exist, but MEMORY.md lists only a and c.
+     *
+     * The individual `<name>.md` files are the source of truth; MEMORY.md is a
+     * derived index. So rather than trusting any cache, re-derive it from disk
+     * inside the lock. `pending` carries this writer's own change, which may not
+     * be visible on disk yet (a delete moves the file to trash first, a save
+     * writes it first) — it is applied on top of the freshly scanned set.
+     */
     private writeIndex;
     private generateId;
     private availableFileNameForId;