@cjhyy/code-shell-core 0.7.0-beta.1 → 0.7.1

package/dist/context/tool-result-storage.d.ts

@@ -55,6 +55,12 @@ export declare function reconstructContentReplacementState(messages: Message[]):
  * transcript path. Layout:  <transcriptDir>/tool-results/
  */
 export declare function resolveToolResultsDir(transcriptPath: string): string;
+/**
+ * Convert an externally supplied tool_use_id to a bounded internal filename.
+ * The original id remains the key in ContentReplacementState/onPersist; it is
+ * never used as a path component.
+ */
+export declare function safeToolResultFilename(toolUseId: string): string;
 interface PersistOptions {
     /** Per-result threshold; default DEFAULT_PERSIST_THRESHOLD. */
     perResultThreshold?: number;

package/dist/context/tool-result-storage.js

@@ -22,7 +22,8 @@
  *     parallel Read results), persist the largest ones first until under.
  */
 import { mkdirSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { createHash } from "node:crypto";
+import { dirname, isAbsolute, join, relative, resolve, sep, win32 } from "node:path";
 import { logger } from "../logging/logger.js";
 // ─── Tunables ───────────────────────────────────────────────────────
 /** Per-result threshold. Larger than this → persist + replace. */
@@ -77,12 +78,32 @@ function ensureDir(dir) {
     }
 }
 /**
- * Write content to <dir>/<toolUseId>.txt. Idempotent: skips if the file
- * already exists (tool_use_id is a UUID, content is deterministic per id).
+ * Convert an externally supplied tool_use_id to a bounded internal filename.
+ * The original id remains the key in ContentReplacementState/onPersist; it is
+ * never used as a path component.
  */
+export function safeToolResultFilename(toolUseId) {
+    if (toolUseId.length > 256) {
+        throw new RangeError("tool_use_id exceeds the 256 character limit");
+    }
+    if (isAbsolute(toolUseId) ||
+        win32.isAbsolute(toolUseId) ||
+        toolUseId.includes("/") ||
+        toolUseId.includes("\\")) {
+        throw new Error("tool_use_id must not contain a path");
+    }
+    return `${createHash("sha256").update(toolUseId, "utf8").digest("hex")}.txt`;
+}
+/** Write content to the contained hashed path. Idempotent by original id. */
 function persistToFile(dir, toolUseId, content) {
+    const root = resolve(dir);
+    const filename = safeToolResultFilename(toolUseId);
+    const filepath = resolve(root, filename);
+    const rel = relative(root, filepath);
+    if (rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
+        throw new Error("tool_result path escaped its storage root");
+    }
     ensureDir(dir);
-    const filepath = join(dir, `${toolUseId}.txt`);
     try {
         // 'wx' = fail if exists. Skipping on collision is correct: same id =
         // same content. Avoids re-writing the same bytes every turn.

package/dist/credentials/access.d.ts

@@ -1,4 +1,4 @@
-import type { Credential, CredentialType } from "./types.js";
+import { type Credential, type CredentialType } from "./types.js";
 import type { SettingsScope } from "../settings/manager.js";
 import type { Transport } from "../protocol/transport.js";
 export type CredentialAccessScope = "full" | "project";
@@ -12,6 +12,7 @@ export interface CredentialMetadata {
     meta?: Credential["meta"];
     hasSecret: boolean;
     secretHint?: string;
+    oauthStatus?: import("./types.js").OAuthCredentialPublicStatus;
 }
 export interface CredentialAccess {
     listMasked(cwd: string | undefined, scope: CredentialAccessScope): CredentialMetadata[];
@@ -23,6 +24,15 @@ export interface CredentialAccess {
         scope: CredentialAccessScope;
         purpose: "use" | "mcp";
     }): Promise<string>;
+    /** Resolve only the bearer material needed by an MCP request. */
+    resolveOAuthAccess?(req: {
+        id: string;
+        scope: "full";
+        forceRefresh?: boolean;
+    }): Promise<{
+        accessToken: string;
+        expiresAt?: string;
+    }>;
     materializeCookie?(req: {
         cwd?: string;
         id: string;

package/dist/credentials/access.js

@@ -2,8 +2,11 @@ import { existsSync, readdirSync, rmSync, statSync, writeFileSync } from "node:f
 import { randomUUID } from "node:crypto";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { credentialAllowsEnvExposure, credentialSecretHint, } from "./types.js";
 import { CredentialStore } from "./store.js";
 import { formatNetscapeCookies, parseCookieJar } from "./cookie-jar.js";
+import { parseOAuthCredentialSecret, shouldRefreshOAuthCredential, summarizeOAuthCredentialSecret, } from "./oauth.js";
+import { refreshToken } from "../services/oauth.js";
 const COOKIE_FILE_PREFIX = "codeshell-cred-cookie-";
 const COOKIE_FILE_MAX_AGE_MS = 30 * 60 * 1000;
 let defaultCredentialAccess = null;
@@ -84,6 +87,16 @@ export function createIpcCredentialAccess(transport) {
                 throw new Error(`credential "${req.id}" is unavailable`);
             return result.value;
         },
+        async resolveOAuthAccess(req) {
+            const result = (await request("desktop/oauthAccessResolve", req));
+            if (typeof result?.accessToken !== "string") {
+                throw new Error(`oauth credential "${req.id}" requires login`);
+            }
+            return {
+                accessToken: result.accessToken,
+                expiresAt: typeof result.expiresAt === "string" ? result.expiresAt : undefined,
+            };
+        },
         async materializeCookie(req) {
             const result = (await request("desktop/credentialMaterializeCookie", req));
             if (typeof result?.cookiesFile !== "string" || typeof result.count !== "number") {
@@ -105,8 +118,10 @@ function toMetadata(cred) {
     const { secret: _secret, ...rest } = cred;
     return {
         ...rest,
+        ...(credentialAllowsEnvExposure(cred.type) ? {} : { exposeAsEnv: undefined }),
         hasSecret: available,
-        secretHint: available ? (secret.length > 4 ? `****${secret.slice(-4)}` : "****") : undefined,
+        secretHint: available ? credentialSecretHint(cred.type, secret) : undefined,
+        ...(cred.type === "oauth" ? { oauthStatus: summarizeOAuthCredentialSecret(secret) } : {}),
     };
 }
 function cloneMetadata(list) {
@@ -127,6 +142,8 @@ export const localCredentialAccess = {
         const out = {};
         const creds = storeFor(cwd).list(scope);
         for (const cred of creds) {
+            if (!credentialAllowsEnvExposure(cred.type))
+                continue;
             const name = cred.exposeAsEnv?.trim();
             if (name && isCredentialSecretAvailable(cred.secret))
                 out[name] = cred.secret;
@@ -140,6 +157,9 @@ export const localCredentialAccess = {
         }
         return cred.secret;
     },
+    async resolveOAuthAccess(req) {
+        return resolveLocalOAuthAccess(req.id, Boolean(req.forceRefresh));
+    },
     async materializeCookie(req) {
         const cred = storeFor(req.cwd).resolve(req.id, req.scope);
         if (!cred || cred.type !== "cookie" || !isCredentialSecretAvailable(cred.secret)) {
@@ -148,6 +168,62 @@ export const localCredentialAccess = {
         return materializeCookieSecret(cred.id, cred.secret);
     },
 };
+const localOAuthRefreshes = new Map();
+async function resolveLocalOAuthAccess(id, forceRefresh) {
+    const store = new CredentialStore(undefined);
+    const cred = store.resolve(id, "full");
+    if (!cred || cred.type !== "oauth" || !isCredentialSecretAvailable(cred.secret)) {
+        throw new Error(`oauth credential "${id}" requires login`);
+    }
+    const parsed = parseOAuthCredentialSecret(cred.secret);
+    const decision = shouldRefreshOAuthCredential(parsed);
+    if (!forceRefresh && decision === "no") {
+        return { accessToken: parsed.accessToken, expiresAt: parsed.expiresAt };
+    }
+    if (!parsed.refreshToken || !parsed.tokenEndpoint || !parsed.clientId) {
+        throw new Error(`oauth credential "${id}" requires login`);
+    }
+    const inflight = localOAuthRefreshes.get(id);
+    if (inflight)
+        return inflight;
+    const pending = (async () => {
+        const latestCred = store.resolve(id, "full");
+        if (!latestCred || latestCred.type !== "oauth" || !latestCred.secret) {
+            throw new Error(`oauth credential "${id}" requires login`);
+        }
+        const latest = parseOAuthCredentialSecret(latestCred.secret);
+        if (!forceRefresh && shouldRefreshOAuthCredential(latest) === "no") {
+            return { accessToken: latest.accessToken, expiresAt: latest.expiresAt };
+        }
+        if (!latest.refreshToken || !latest.tokenEndpoint || !latest.clientId) {
+            throw new Error(`oauth credential "${id}" requires login`);
+        }
+        const tokens = await refreshToken({
+            clientId: latest.clientId,
+            clientSecret: latest.clientSecret,
+            tokenEndpoint: latest.tokenEndpoint,
+            authorizationEndpoint: "",
+            scopes: latest.scopes,
+            resource: latest.resource,
+        }, latest.refreshToken);
+        const next = {
+            ...latest,
+            accessToken: tokens.accessToken,
+            refreshToken: tokens.refreshToken ?? latest.refreshToken,
+            expiresAt: tokens.expiresAt ? new Date(tokens.expiresAt).toISOString() : undefined,
+            tokenType: tokens.tokenType,
+            scope: tokens.scope ?? latest.scope,
+        };
+        store.save("user", {
+            ...latestCred,
+            secret: JSON.stringify(next),
+            meta: { ...latestCred.meta, lastRefreshAt: new Date().toISOString() },
+        });
+        return { accessToken: next.accessToken, expiresAt: next.expiresAt };
+    })().finally(() => localOAuthRefreshes.delete(id));
+    localOAuthRefreshes.set(id, pending);
+    return pending;
+}
 export function materializeCookieSecret(credentialId, secret) {
     const jar = parseCookieJar(secret);
     if (jar.length === 0)

package/dist/credentials/index.d.ts

@@ -2,7 +2,9 @@ export { CredentialStore } from "./store.js";
 export type { CredentialScope, MaskedCredential } from "./store.js";
 export { type EncryptionCipher, PlaintextCipher, setDefaultCredentialCipher, getDefaultCredentialCipher, } from "./cipher.js";
 export { getCredentialAccess, setDefaultCredentialAccess, createIpcCredentialAccess, localCredentialAccess, credentialAccessScope, isCredentialSecretAvailable, materializeCookieSecret, type CredentialAccess, type CredentialAccessScope, type CredentialMetadata, type CredentialSnapshot, type CredentialSnapshotEntry, } from "./access.js";
-export type { Credential, CredentialType, CredentialStoreFile } from "./types.js";
+export type { Credential, CredentialType, CredentialStoreFile, OAuthCredentialPublicStatus, OAuthCredentialSecret, OAuthTokenResponse, } from "./types.js";
+export { credentialAllowsEnvExposure, credentialSecretHint } from "./types.js";
+export { buildOAuthRefreshRequest, isOAuthAccessTokenExpired, oauthCredentialStatus, parseOAuthCredentialSecret, mergeOAuthTokenResponse, shouldRefreshOAuthCredential, summarizeOAuthCredentialSecret, type OAuthClockOptions, type OAuthRefreshHandler, type OAuthRefreshRequest, } from "./oauth.js";
 export { formatNetscapeCookies, parseCookieJar, type CookieLike } from "./cookie-jar.js";
 export { useCredentialToolDef, useCredentialToolDefFor, useCredentialTool, sweepStaleCredentialCookies, } from "./use-credential-tool.js";
 export { credentialUseGate } from "./use-gate.js";

package/dist/credentials/index.js

@@ -1,6 +1,8 @@
 export { CredentialStore } from "./store.js";
 export { PlaintextCipher, setDefaultCredentialCipher, getDefaultCredentialCipher, } from "./cipher.js";
 export { getCredentialAccess, setDefaultCredentialAccess, createIpcCredentialAccess, localCredentialAccess, credentialAccessScope, isCredentialSecretAvailable, materializeCookieSecret, } from "./access.js";
+export { credentialAllowsEnvExposure, credentialSecretHint } from "./types.js";
+export { buildOAuthRefreshRequest, isOAuthAccessTokenExpired, oauthCredentialStatus, parseOAuthCredentialSecret, mergeOAuthTokenResponse, shouldRefreshOAuthCredential, summarizeOAuthCredentialSecret, } from "./oauth.js";
 export { formatNetscapeCookies, parseCookieJar } from "./cookie-jar.js";
 export { useCredentialToolDef, useCredentialToolDefFor, useCredentialTool, sweepStaleCredentialCookies, } from "./use-credential-tool.js";
 export { credentialUseGate } from "./use-gate.js";

package/dist/credentials/oauth.d.ts

@@ -0,0 +1,25 @@
+import type { OAuthCredentialPublicStatus, OAuthCredentialSecret, OAuthTokenResponse } from "./types.js";
+export interface OAuthClockOptions {
+    now?: number | (() => number);
+    skewMs?: number;
+}
+export interface OAuthRefreshRequest {
+    credentialId: string;
+    tokenEndpoint: string;
+    refreshToken: string;
+    clientId?: string;
+    clientSecret?: string;
+    scope?: string;
+    scopes?: string[];
+}
+export type OAuthRefreshHandler = (req: OAuthRefreshRequest) => Promise<OAuthCredentialSecret>;
+export declare function parseOAuthCredentialSecret(secret: string): OAuthCredentialSecret;
+/** Merge and validate an OAuth token endpoint response without losing rotation state. */
+export declare function mergeOAuthTokenResponse(previous: OAuthCredentialSecret | undefined, response: OAuthTokenResponse, opts?: {
+    now?: number;
+}): OAuthCredentialSecret;
+export declare function shouldRefreshOAuthCredential(secret: OAuthCredentialSecret, opts?: OAuthClockOptions): "no" | "refresh" | "login_required";
+export declare function isOAuthAccessTokenExpired(secret: Pick<OAuthCredentialSecret, "accessToken" | "expiresAt">, opts?: OAuthClockOptions): boolean;
+export declare function oauthCredentialStatus(secret: Pick<OAuthCredentialSecret, "accessToken" | "expiresAt">, opts?: OAuthClockOptions): Pick<OAuthCredentialPublicStatus, "state" | "expiresAt" | "expiresInMs">;
+export declare function buildOAuthRefreshRequest(credentialId: string, secret: OAuthCredentialSecret): OAuthRefreshRequest | undefined;
+export declare function summarizeOAuthCredentialSecret(secret: string | undefined, opts?: OAuthClockOptions): OAuthCredentialPublicStatus;

package/dist/credentials/oauth.js

@@ -0,0 +1,179 @@
+const DEFAULT_OAUTH_REFRESH_SKEW_MS = 60_000;
+function nowMs(opts = {}) {
+    if (typeof opts.now === "function")
+        return opts.now();
+    if (typeof opts.now === "number")
+        return opts.now;
+    return Date.now();
+}
+function optionalString(value) {
+    return typeof value === "string" && value.length > 0 ? value : undefined;
+}
+function optionalStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const out = value.filter((x) => typeof x === "string" && x.length > 0);
+    return out.length > 0 ? out : undefined;
+}
+function optionalFiniteNumber(value) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error("OAuth token response expires_in must be a finite non-negative number");
+    }
+    if (value < 0) {
+        throw new Error("OAuth token response expires_in must be a finite non-negative number");
+    }
+    return value;
+}
+function parseExpiresAt(value) {
+    if (!value)
+        return undefined;
+    const ms = Date.parse(value);
+    if (!Number.isFinite(ms)) {
+        throw new Error(`OAuth credential secret has invalid expiresAt: ${value}`);
+    }
+    return ms;
+}
+export function parseOAuthCredentialSecret(secret) {
+    let parsed;
+    try {
+        parsed = JSON.parse(secret);
+    }
+    catch {
+        throw new Error("OAuth credential secret must be a JSON object");
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+        throw new Error("OAuth credential secret must be a JSON object");
+    }
+    const raw = parsed;
+    if (raw.version !== undefined && raw.version !== 1) {
+        throw new Error("OAuth credential secret version must be 1");
+    }
+    const accessToken = optionalString(raw.accessToken);
+    if (!accessToken) {
+        throw new Error("OAuth credential secret must include accessToken");
+    }
+    const expiresAt = optionalString(raw.expiresAt);
+    parseExpiresAt(expiresAt);
+    const tokenType = optionalString(raw.tokenType);
+    if (tokenType && tokenType.toLowerCase() !== "bearer") {
+        throw new Error("OAuth credential tokenType must be Bearer");
+    }
+    return {
+        version: raw.version === 1 ? 1 : undefined,
+        accessToken,
+        refreshToken: optionalString(raw.refreshToken),
+        expiresAt,
+        tokenType,
+        scope: optionalString(raw.scope),
+        scopes: optionalStringArray(raw.scopes),
+        tokenEndpoint: optionalString(raw.tokenEndpoint),
+        clientId: optionalString(raw.clientId),
+        clientSecret: optionalString(raw.clientSecret),
+        issuer: optionalString(raw.issuer),
+        resource: optionalString(raw.resource),
+        revocationEndpoint: optionalString(raw.revocationEndpoint),
+        clientRegistration: raw.clientRegistration &&
+            typeof raw.clientRegistration === "object" &&
+            !Array.isArray(raw.clientRegistration) &&
+            optionalString(raw.clientRegistration.clientId)
+            ? {
+                clientId: optionalString(raw.clientRegistration.clientId),
+                clientSecret: optionalString(raw.clientRegistration.clientSecret),
+                clientIdIssuedAt: typeof raw.clientRegistration.clientIdIssuedAt ===
+                    "number"
+                    ? raw.clientRegistration.clientIdIssuedAt
+                    : undefined,
+                clientSecretExpiresAt: typeof raw.clientRegistration.clientSecretExpiresAt ===
+                    "number"
+                    ? raw.clientRegistration
+                        .clientSecretExpiresAt
+                    : undefined,
+            }
+            : undefined,
+    };
+}
+/** Merge and validate an OAuth token endpoint response without losing rotation state. */
+export function mergeOAuthTokenResponse(previous, response, opts = {}) {
+    const accessToken = optionalString(response.access_token);
+    if (!accessToken)
+        throw new Error("OAuth token response must include access_token");
+    const tokenType = optionalString(response.token_type) ?? "Bearer";
+    if (tokenType.toLowerCase() !== "bearer") {
+        throw new Error(`OAuth token response token_type must be Bearer`);
+    }
+    const expiresIn = optionalFiniteNumber(response.expires_in);
+    const now = opts.now ?? Date.now();
+    const responseScope = optionalString(response.scope);
+    const refreshToken = optionalString(response.refresh_token) ?? previous?.refreshToken;
+    return {
+        ...previous,
+        version: 1,
+        accessToken,
+        refreshToken,
+        expiresAt: expiresIn === undefined ? undefined : new Date(now + expiresIn * 1000).toISOString(),
+        tokenType: "Bearer",
+        scope: responseScope ?? previous?.scope,
+        scopes: responseScope ? responseScope.split(/\s+/).filter(Boolean) : previous?.scopes,
+    };
+}
+export function shouldRefreshOAuthCredential(secret, opts = {}) {
+    if (!isOAuthAccessTokenExpired(secret, opts))
+        return "no";
+    return secret.refreshToken && secret.tokenEndpoint ? "refresh" : "login_required";
+}
+export function isOAuthAccessTokenExpired(secret, opts = {}) {
+    const expiresAtMs = parseExpiresAt(secret.expiresAt);
+    if (expiresAtMs === undefined)
+        return false;
+    const skewMs = opts.skewMs ?? DEFAULT_OAUTH_REFRESH_SKEW_MS;
+    return expiresAtMs <= nowMs(opts) + skewMs;
+}
+export function oauthCredentialStatus(secret, opts = {}) {
+    const expiresAtMs = parseExpiresAt(secret.expiresAt);
+    if (expiresAtMs === undefined) {
+        return { state: "valid", expiresAt: undefined, expiresInMs: undefined };
+    }
+    const expiresInMs = expiresAtMs - nowMs(opts);
+    return {
+        state: isOAuthAccessTokenExpired(secret, opts) ? "expired" : "valid",
+        expiresAt: secret.expiresAt,
+        expiresInMs,
+    };
+}
+export function buildOAuthRefreshRequest(credentialId, secret) {
+    if (!secret.refreshToken || !secret.tokenEndpoint)
+        return undefined;
+    return {
+        credentialId,
+        tokenEndpoint: secret.tokenEndpoint,
+        refreshToken: secret.refreshToken,
+        clientId: secret.clientId,
+        clientSecret: secret.clientSecret,
+        scope: secret.scope,
+        scopes: secret.scopes,
+    };
+}
+export function summarizeOAuthCredentialSecret(secret, opts = {}) {
+    if (!secret)
+        return { state: "missing" };
+    try {
+        const parsed = parseOAuthCredentialSecret(secret);
+        const status = oauthCredentialStatus(parsed, opts);
+        return {
+            ...status,
+            hasRefreshToken: Boolean(parsed.refreshToken),
+            tokenEndpoint: parsed.tokenEndpoint,
+            clientId: parsed.clientId,
+            scope: parsed.scope,
+            scopes: parsed.scopes,
+        };
+    }
+    catch (err) {
+        return {
+            state: "invalid",
+            error: err instanceof Error ? err.message : String(err),
+        };
+    }
+}

package/dist/credentials/store.d.ts

@@ -1,10 +1,11 @@
-import type { Credential } from "./types.js";
+import { type Credential } from "./types.js";
 import { type EncryptionCipher } from "./cipher.js";
 export type CredentialScope = "user" | "project";
 export interface MaskedCredential extends Omit<Credential, "secret"> {
     hasSecret: boolean;
     /** 形如 `****abcd`,绝不含完整明文。 */
     secretHint?: string;
+    oauthStatus?: import("./types.js").OAuthCredentialPublicStatus;
 }
 /**
  * 两层凭证库,镜像 SettingsManager 的 user(~/.code-shell)/ project(<cwd>/.code-shell)

package/dist/credentials/store.js

@@ -1,8 +1,10 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, renameSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { homedir } from "node:os";
+import { credentialAllowsEnvExposure, credentialSecretHint, } from "./types.js";
 import { getDefaultCredentialCipher } from "./cipher.js";
 import { logger } from "../logging/logger.js";
+import { summarizeOAuthCredentialSecret } from "./oauth.js";
 /** 测试可经 process.env.HOME 覆盖(镜像 settings/manager.ts userHome)。 */
 function userHome() {
     return process.env.HOME ?? homedir();
@@ -92,11 +94,14 @@ export class CredentialStore {
     /** Upsert by id within a scope. */
     save(scope, cred) {
         const file = this.read(scope);
+        const safeCredential = credentialAllowsEnvExposure(cred.type)
+            ? cred
+            : { ...cred, exposeAsEnv: undefined };
         const idx = file.credentials.findIndex((c) => c.id === cred.id);
         if (idx >= 0)
-            file.credentials[idx] = cred;
+            file.credentials[idx] = safeCredential;
         else
-            file.credentials.push(cred);
+            file.credentials.push(safeCredential);
         this.write(scope, file);
     }
     /**
@@ -109,7 +114,12 @@ export class CredentialStore {
         const idx = file.credentials.findIndex((c) => c.id === id);
         if (idx < 0)
             return;
-        file.credentials[idx] = { ...file.credentials[idx], ...fields };
+        const current = file.credentials[idx];
+        file.credentials[idx] = {
+            ...current,
+            ...fields,
+            ...(credentialAllowsEnvExposure(current.type) ? {} : { exposeAsEnv: undefined }),
+        };
         this.write(scope, file);
     }
     remove(scope, id) {
@@ -160,6 +170,8 @@ export class CredentialStore {
             : [this.read("user").credentials, this.read("project").credentials];
         for (const layer of layers) {
             for (const c of layer) {
+                if (!credentialAllowsEnvExposure(c.type))
+                    continue;
                 const name = c.exposeAsEnv?.trim();
                 if (name && typeof c.secret === "string" && c.secret.length > 0) {
                     out[name] = c.secret;
@@ -173,11 +185,10 @@ export class CredentialStore {
             const { secret, ...rest } = c;
             return {
                 ...rest,
+                ...(credentialAllowsEnvExposure(c.type) ? {} : { exposeAsEnv: undefined }),
                 hasSecret: typeof secret === "string" && secret.length > 0,
-                // Reveal at most the last 4 chars — and ONLY when the secret is longer
-                // than 4, so those chars aren't the whole secret. `"ab".slice(-4)` is
-                // "ab", so a short secret would otherwise leak in full through the hint.
-                secretHint: secret ? (secret.length > 4 ? `****${secret.slice(-4)}` : "****") : undefined,
+                secretHint: credentialSecretHint(c.type, secret),
+                ...(c.type === "oauth" ? { oauthStatus: summarizeOAuthCredentialSecret(secret) } : {}),
             };
         });
     }

package/dist/credentials/types.d.ts

@@ -3,7 +3,68 @@
  * - token/link 第一期已有;cookie 第二期改为「具名 cookie 凭证」进库
  *   (用户主动按域拓取存,支持同域多账号),见 credential-use-gate 设计稿。
  */
-export type CredentialType = "token" | "link" | "cookie";
+export type CredentialType = "token" | "link" | "cookie" | "oauth";
+/**
+ * Only established single-value credentials may be copied into a process
+ * environment. OAuth records and cookie jars are structured multi-secret
+ * values and must remain behind the credential resolver boundary.
+ */
+export declare function credentialAllowsEnvExposure(type: CredentialType): boolean;
+/** Build a renderer-safe hint without deriving bytes from structured JSON. */
+export declare function credentialSecretHint(type: CredentialType, secret: string | undefined): string | undefined;
+export interface OAuthCredentialSecret {
+    /** Schema version for the JSON stored in Credential.secret. */
+    version?: 1;
+    /** Current access token. MCP HTTP auth sends this as Authorization: Bearer. */
+    accessToken: string;
+    /** Optional refresh token. Stored encrypted with the credential secret. */
+    refreshToken?: string;
+    /** ISO-8601 expiry time for accessToken. Missing means "unknown", not expired. */
+    expiresAt?: string;
+    /** Upstream token type, usually Bearer. Stored for round-trip/debugging. */
+    tokenType?: string;
+    /** Space-delimited OAuth scope string returned by many token endpoints. */
+    scope?: string;
+    /** Structured scopes used by first-party UI/catalog metadata. */
+    scopes?: string[];
+    /** Token endpoint to use when a future refresh flow is wired. */
+    tokenEndpoint?: string;
+    /** OAuth client id associated with this token. */
+    clientId?: string;
+    /** Optional confidential client secret, if the integration requires it. */
+    clientSecret?: string;
+    /** OAuth issuer discovered for the MCP protected resource. */
+    issuer?: string;
+    /** RFC 8707 resource indicator used for authorization/token requests. */
+    resource?: string;
+    /** Optional endpoint used to revoke the refresh/access token on logout. */
+    revocationEndpoint?: string;
+    /** Dynamic registration result, retained with the encrypted secret. */
+    clientRegistration?: {
+        clientId: string;
+        clientSecret?: string;
+        clientIdIssuedAt?: number;
+        clientSecretExpiresAt?: number;
+    };
+}
+export interface OAuthTokenResponse {
+    access_token: unknown;
+    refresh_token?: unknown;
+    expires_in?: unknown;
+    token_type?: unknown;
+    scope?: unknown;
+}
+export interface OAuthCredentialPublicStatus {
+    state: "valid" | "expired" | "missing" | "invalid";
+    expiresAt?: string;
+    expiresInMs?: number;
+    hasRefreshToken?: boolean;
+    tokenEndpoint?: string;
+    clientId?: string;
+    scope?: string;
+    scopes?: string[];
+    error?: string;
+}
 export interface Credential {
     /**
      * 引用键,kebab-case,全局/项目两层内唯一。
@@ -19,6 +80,7 @@ export interface Credential {
      * 密文(UI 只显示掩码):
      * - token: token 值;
      * - link: client id/secret 等的 JSON 字符串;
+     * - oauth: OAuthCredentialSecret JSON 字符串(access/refresh/expiry/client info);
      * - cookie: 序列化的 cookie jar(JSON.stringify 的 ElectronCookieLike[])。
      */
     secret?: string;
@@ -48,6 +110,27 @@ export interface Credential {
         domain?: string;
         scope?: "domain" | "all";
         switchMode?: "clear" | "merge";
+        /** OAuth provider/integration id, e.g. "figma". */
+        oauthProvider?: string;
+        /** MCP server identity associated with an advanced OAuth login. */
+        mcpServerName?: string;
+        mcpServerUrl?: string;
+        issuer?: string;
+        resource?: string;
+        /** OAuth authorization endpoint, used by UI/login launchers. */
+        authUrl?: string;
+        /** OAuth token endpoint, duplicated from secret for non-secret UI display. */
+        tokenEndpoint?: string;
+        /** OAuth client id, duplicated from secret for non-secret UI display. */
+        clientId?: string;
+        /** OAuth scopes requested for this credential. */
+        scopes?: string[];
+        revocationEndpoint?: string;
+        /** Last successful refresh time. */
+        lastRefreshAt?: string;
+        /** Normalized refresh diagnostics; never contains endpoint response bodies. */
+        lastRefreshFailedAt?: string;
+        lastRefreshErrorCode?: "invalid_grant" | "network" | "server_error" | "invalid_response";
     };
 }
 export interface CredentialStoreFile {

package/dist/credentials/types.js

@@ -1 +1,16 @@
-export {};
+/**
+ * Only established single-value credentials may be copied into a process
+ * environment. OAuth records and cookie jars are structured multi-secret
+ * values and must remain behind the credential resolver boundary.
+ */
+export function credentialAllowsEnvExposure(type) {
+    return type === "token" || type === "link";
+}
+/** Build a renderer-safe hint without deriving bytes from structured JSON. */
+export function credentialSecretHint(type, secret) {
+    if (!secret)
+        return undefined;
+    if (type === "oauth" || type === "cookie")
+        return "****";
+    return secret.length > 4 ? `****${secret.slice(-4)}` : "****";
+}