@dipoleml/dcode-cli 1.1.0 → 1.2.1

package/node_modules/@dcode/shared/dist/project-access-token-client.d.ts

@@ -0,0 +1,42 @@
+export interface ProjectAccessTokenInput {
+    readonly rejectedProjectTokenFingerprint?: string;
+    readonly origin: string;
+    readonly family: "bigmodel" | "dcode";
+    readonly loginToken: string;
+    readonly accountId: string;
+    /** 保留各调用端既有项目选择；CLI 默认项目不排除团队类型。 */
+    readonly personalProjectSelection?: "non-team" | "default";
+    readonly team?: {
+        readonly organizationId: string;
+        readonly projectId: string;
+    };
+}
+export interface ProjectAccessTokenMaterial {
+    readonly token: string;
+    readonly apiKeyId: string;
+    readonly organizationId: string;
+    readonly projectId: string;
+}
+/** Host/CLI 各自持有实例；网络由已有 adapter 注入，凭据不进入配置或磁盘。 */
+export declare class ProjectAccessTokenClient {
+    #private;
+    private readonly options;
+    constructor(options: {
+        request(url: string, init: RequestInit): Promise<unknown>;
+        observe?(event: {
+            family: string;
+            stage: "resolve";
+            code: string;
+        }): void;
+        locationStore?: {
+            load(key: string): Promise<string | null>;
+            save(key: string, value: string): Promise<void>;
+            delete(key: string): Promise<void>;
+        };
+        now?: () => number;
+        random?: () => number;
+    });
+    clear(): void;
+    resolve(input: ProjectAccessTokenInput): Promise<ProjectAccessTokenMaterial>;
+}
+//# sourceMappingURL=project-access-token-client.d.ts.map

package/node_modules/@dcode/shared/dist/project-access-token-client.js

@@ -0,0 +1,260 @@
+import { z } from "zod";
+import { projectTokenSuccessCodeSchema } from "./project-access-token-response.js";
+import { API_KEY_USAGE_SCENE } from "./api-key-usage-scene.js";
+import { ProjectAccessTokenCache, ProjectAccessTokenError } from "./project-access-token.js";
+import { DCODE_VERSION } from "./version.js";
+const DEFAULT_ORGANIZATION_NAME = "默认机构";
+const DEFAULT_PROJECT_NAME = "默认项目";
+const customerSchema = z.object({
+    organizations: z
+        .array(z.object({
+        organizationId: z.string(),
+        organizationName: z.string().nullish(),
+        projects: z
+            .array(z.object({
+            projectId: z.string(),
+            projectName: z.string().nullish(),
+            projectType: z.union([z.string(), z.number()]).nullish(),
+        }))
+            .default([]),
+    }))
+        .default([]),
+});
+const keySchema = z.object({
+    apiKey: z.string().trim().min(1),
+    name: z.string().nullish(),
+    keyType: z.number().nullish(),
+});
+const envelopeSchema = z.object({
+    code: projectTokenSuccessCodeSchema,
+    data: z.unknown(),
+});
+const locationSchema = z.object({
+    organizationId: z.string().min(1),
+    projectId: z.string().min(1),
+    apiKeyId: z.string().min(1),
+});
+/** Host/CLI 各自持有实例；网络由已有 adapter 注入，凭据不进入配置或磁盘。 */
+export class ProjectAccessTokenClient {
+    options;
+    #sessions = new Map();
+    #generation = 0;
+    constructor(options) {
+        this.options = options;
+    }
+    clear() {
+        for (const session of this.#sessions.values())
+            session.cache.clear();
+        this.#sessions.clear();
+    }
+    async resolve(input) {
+        const origin = new URL(input.origin).origin;
+        const loginToken = input.loginToken.trim().replace(/^Bearer\s+/i, "");
+        if (!loginToken || !input.accountId.trim())
+            throw new Error("project_token_login_required");
+        const sessionKey = JSON.stringify([origin, input.family]);
+        let session = this.#sessions.get(sessionKey);
+        if (!session || session.token !== loginToken) {
+            session?.cache.clear();
+            session = {
+                token: loginToken,
+                generation: String(++this.#generation),
+                locations: new Map(),
+                cache: new ProjectAccessTokenCache({
+                    now: this.options.now,
+                    random: this.options.random,
+                    onRefreshDeferred: () => this.options.observe?.({
+                        family: input.family,
+                        stage: "resolve",
+                        code: "project_token_refresh_deferred",
+                    }),
+                }),
+            };
+            this.#sessions.set(sessionKey, session);
+        }
+        const current = session;
+        const assertCurrent = () => {
+            if (this.#sessions.get(sessionKey) !== current)
+                throw new ProjectAccessTokenError("project_token_scope_invalidated");
+        };
+        const headers = {
+            Authorization: `Bearer ${loginToken}`,
+            "Content-Type": "application/json",
+        };
+        const request = async (url, init) => {
+            assertCurrent();
+            const result = await this.options.request(url, init);
+            assertCurrent();
+            return result;
+        };
+        try {
+            const selection = input.team ? null : (input.personalProjectSelection ?? "non-team");
+            const locationKey = JSON.stringify([input.accountId, input.team ?? null, selection]);
+            const storageKey = `project-key-location:v1:${encodeURIComponent(JSON.stringify([origin, input.family, input.accountId, input.team ?? null, API_KEY_USAGE_SCENE.CODING_PLAN, selection]))}`;
+            let pending = current.locations.get(locationKey);
+            if (!pending) {
+                pending = (async () => {
+                    const saved = await this.options.locationStore?.load(storageKey);
+                    assertCurrent();
+                    if (saved) {
+                        let parsed;
+                        try {
+                            parsed = JSON.parse(saved);
+                        }
+                        catch {
+                            /* 损坏记录通过正常元数据流程重建。 */
+                        }
+                        const value = locationSchema.safeParse(parsed);
+                        if (value.success &&
+                            (!input.team ||
+                                (value.data.organizationId === input.team.organizationId &&
+                                    value.data.projectId === input.team.projectId)))
+                            return value.data;
+                    }
+                    const result = await this.#resolveLocation(input, origin, loginToken, request);
+                    assertCurrent();
+                    await this.options.locationStore?.save(storageKey, JSON.stringify(result));
+                    assertCurrent();
+                    return result;
+                })();
+                current.locations.set(locationKey, pending);
+                void pending.catch(() => {
+                    if (current.locations.get(locationKey) === pending)
+                        current.locations.delete(locationKey);
+                });
+            }
+            const location = await pending;
+            assertCurrent();
+            const value = await current.cache.resolve({
+                origin,
+                family: input.family,
+                accountId: input.accountId,
+                ...location,
+                usageScene: API_KEY_USAGE_SCENE.CODING_PLAN,
+                loginGeneration: current.generation,
+            }, async () => {
+                const raw = await request(`${keyListUrl(origin, location)}/${encodeURIComponent(location.apiKeyId)}/access_tokens`, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify({
+                        clientType: "dcode",
+                        clientVersion: DCODE_VERSION,
+                    }),
+                });
+                // 仅明确不存在才废弃 ID；权限/网络/开关错误不能触发创建或 Key 回退。
+                if (raw && typeof raw === "object" && "code" in raw && raw.code === 404) {
+                    current.locations.delete(locationKey);
+                    await this.options.locationStore?.delete(storageKey);
+                }
+                return raw;
+            }, input.rejectedProjectTokenFingerprint);
+            assertCurrent();
+            if (!value.enabled)
+                throw new Error("project_token_disabled");
+            return { token: value.token, ...location };
+        }
+        catch (error) {
+            // 上游错误体或网络异常可能携带凭据；只传播固定错误码，不保留原始 cause/message。
+            const code = error instanceof ProjectAccessTokenError
+                ? error.code
+                : error instanceof Error &&
+                    [
+                        "project_token_disabled",
+                        "project_token_project_unavailable",
+                        "project_token_invalid_response",
+                    ].includes(error.message)
+                    ? error.message
+                    : "project_token_request_failed";
+            this.options.observe?.({ family: input.family, stage: "resolve", code });
+            throw new Error(code);
+        }
+    }
+    async #resolveLocation(input, origin, loginToken, request) {
+        // 管理接口沿用旧鉴权格式；不能把签发端的 Bearer 约定扩散到所有端点。
+        const headers = {
+            Authorization: input.family === "dcode" ? `Bearer ${loginToken}` : loginToken,
+            "Content-Type": "application/json",
+        };
+        const customer = customerSchema.safeParse(readData(await request(`${origin}/api/biz/customer/getCustomerInfo`, {
+            method: "GET",
+            headers,
+        })));
+        if (!customer.success)
+            throw new Error("project_token_invalid_response");
+        const organizations = customer.data.organizations;
+        let location = input.team;
+        if (location) {
+            if (!organizations.some((org) => org.organizationId.trim() === location.organizationId.trim() &&
+                org.projects.some((p) => p.projectId.trim() === location.projectId.trim())))
+                throw new Error("project_token_project_unavailable");
+        }
+        else {
+            const personal = input.personalProjectSelection === "default"
+                ? organizations
+                : organizations
+                    .map((org) => ({
+                    ...org,
+                    projects: org.projects.filter((p) => String(p.projectType ?? "").trim() !== "2"),
+                }))
+                    .filter((org) => org.organizationId && org.projects.length);
+            const org = personal.find((org) => org.organizationName?.includes(DEFAULT_ORGANIZATION_NAME)) ??
+                personal[0];
+            const project = org?.projects.find((p) => p.projectName?.includes(DEFAULT_PROJECT_NAME)) ??
+                org?.projects[0];
+            if (!org?.organizationId || !project?.projectId)
+                throw new Error("project_token_project_unavailable");
+            location = {
+                organizationId: org.organizationId,
+                projectId: project.projectId,
+            };
+        }
+        const url = keyListUrl(origin, location);
+        const name = input.team ? "dcode-team-api-key" : "dcode-api-key";
+        const keyHeaders = input.team
+            ? {
+                ...headers,
+                Authorization: loginToken,
+                "bigmodel-organization": location.organizationId,
+                "bigmodel-project": location.projectId,
+            }
+            : headers;
+        const list = z
+            .array(z.unknown())
+            .safeParse(readData(await request(url, { method: "GET", headers: keyHeaders })));
+        if (!list.success)
+            throw new Error("project_token_invalid_response");
+        // 列表可能含无关坏条目。个人同名条目缺 ID 时禁止重复创建；团队只复用有效条目。
+        const candidate = list.data.find((entry) => {
+            if (!entry || typeof entry !== "object" || !("name" in entry) || entry.name !== name)
+                return false;
+            if (!input.team)
+                return true;
+            const parsed = keySchema.safeParse(entry);
+            return parsed.success && parsed.data.keyType === 2;
+        });
+        const rawKey = candidate ??
+            readData(await request(url, {
+                method: "POST",
+                headers: keyHeaders,
+                body: JSON.stringify({
+                    name,
+                    ...(input.team ? { keyType: 2 } : {}),
+                    usageScene: API_KEY_USAGE_SCENE.CODING_PLAN,
+                }),
+            }));
+        const key = keySchema.safeParse(rawKey);
+        if (!key.success || (input.team && (key.data.name !== name || key.data.keyType !== 2)))
+            throw new Error("project_token_invalid_response");
+        return { ...location, apiKeyId: key.data.apiKey };
+    }
+}
+function keyListUrl(origin, location) {
+    return `${origin}/api/biz/v1/organization/${encodeURIComponent(location.organizationId)}/projects/${encodeURIComponent(location.projectId)}/api_keys`;
+}
+function readData(raw) {
+    const value = envelopeSchema.safeParse(raw);
+    if (!value.success)
+        throw new Error("project_token_invalid_response");
+    return value.data.data;
+}
+//# sourceMappingURL=project-access-token-client.js.map

package/node_modules/@dcode/shared/dist/project-access-token-response.d.ts

@@ -0,0 +1,4 @@
+import { z } from "zod";
+/** BigModel/DipoleML 管理及 PAT 签发共用的成功 envelope 码；不放宽 Token 内容校验。 */
+export declare const projectTokenSuccessCodeSchema: z.ZodUnion<readonly [z.ZodLiteral<200>, z.ZodLiteral<0>, z.ZodLiteral<"200">, z.ZodLiteral<"0">]>;
+//# sourceMappingURL=project-access-token-response.d.ts.map

package/node_modules/@dcode/shared/dist/project-access-token-response.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+/** BigModel/DipoleML 管理及 PAT 签发共用的成功 envelope 码；不放宽 Token 内容校验。 */
+export const projectTokenSuccessCodeSchema = z.union([
+    z.literal(200),
+    z.literal(0),
+    z.literal("200"),
+    z.literal("0"),
+]);
+//# sourceMappingURL=project-access-token-response.js.map

package/node_modules/@dcode/shared/dist/project-access-token.d.ts

@@ -0,0 +1,45 @@
+import type { ApiKeyCreationUsageScene } from "./api-key-usage-scene.js";
+export interface ProjectAccessTokenScope {
+    readonly origin: string;
+    readonly family: "bigmodel" | "dcode";
+    readonly accountId: string;
+    readonly organizationId: string;
+    readonly projectId: string;
+    readonly apiKeyId: string;
+    readonly usageScene: ApiKeyCreationUsageScene;
+    /** 登录生命周期标识，不能使用 Token 原文或短期 Token 的哈希。 */
+    readonly loginGeneration: string;
+}
+export type ProjectAccessTokenResult = {
+    readonly enabled: false;
+} | {
+    readonly enabled: true;
+    readonly token: string;
+    readonly expiresAt: number;
+};
+export declare class ProjectAccessTokenError extends Error {
+    readonly code: "project_token_invalid_response" | "project_token_scope_invalidated";
+    constructor(code: "project_token_invalid_response" | "project_token_scope_invalidated");
+}
+/** I/O adapter 确认的临时故障；不携带原始响应、URL、Token 或 cause。 */
+export declare class ProjectAccessTokenTransientError extends Error {
+    constructor();
+}
+/**
+ * 账号鉴权 owner 的纯内存状态，不含网络、存储、定时器或全局单例。
+ * Host 和 Standalone 分别持有实例；签发由其已有 I/O adapter 注入。
+ */
+export declare class ProjectAccessTokenCache {
+    #private;
+    constructor(options?: {
+        now?: () => number;
+        random?: () => number;
+        onRefreshDeferred?: () => void;
+    });
+    resolve(scope: ProjectAccessTokenScope, issue: () => Promise<unknown>, rejectedFingerprint?: string): Promise<ProjectAccessTokenResult>;
+    invalidate(scope: ProjectAccessTokenScope): void;
+    clear(): void;
+}
+/** 仅用于拒绝某一代 PAT 的比较，不作为账号身份，也不传给模型上游。 */
+export declare function projectAccessTokenFingerprint(token: string): Promise<string>;
+//# sourceMappingURL=project-access-token.d.ts.map

package/node_modules/@dcode/shared/dist/project-access-token.js

@@ -0,0 +1,164 @@
+import { z } from "zod";
+import { projectTokenSuccessCodeSchema } from "./project-access-token-response.js";
+const SECOND_MS = 1_000;
+const REFRESH_LEAD_MS = 120 * SECOND_MS;
+const REFRESH_JITTER_MS = 60 * SECOND_MS;
+const REFRESH_RETRY_BACKOFF_MS = 5 * SECOND_MS;
+const responseSchema = z.preprocess((raw) => {
+    if (raw &&
+        typeof raw === "object" &&
+        "data" in raw &&
+        raw.data &&
+        typeof raw.data === "object" &&
+        !("enable" in raw.data)) {
+        return { ...raw, data: { ...raw.data, enable: true } };
+    }
+    return raw;
+}, z.object({
+    code: projectTokenSuccessCodeSchema,
+    data: z.discriminatedUnion("enable", [
+        z.object({ enable: z.literal(false) }),
+        z.object({
+            enable: z.literal(true),
+            accessToken: z.string().trim().min(1),
+            tokenType: z.literal("Bearer"),
+            expiresIn: z.number().finite().positive(),
+            expiresAt: z.number().finite().positive(),
+        }),
+    ]),
+}));
+export class ProjectAccessTokenError extends Error {
+    code;
+    constructor(code) {
+        // 响应包含凭据；不把 zod issues、原始响应或 Token 放进异常/日志。
+        super(code);
+        this.code = code;
+        this.name = "ProjectAccessTokenError";
+    }
+}
+/** I/O adapter 确认的临时故障；不携带原始响应、URL、Token 或 cause。 */
+export class ProjectAccessTokenTransientError extends Error {
+    constructor() {
+        super("project_token_transient_failure");
+        this.name = "ProjectAccessTokenTransientError";
+    }
+}
+/**
+ * 账号鉴权 owner 的纯内存状态，不含网络、存储、定时器或全局单例。
+ * Host 和 Standalone 分别持有实例；签发由其已有 I/O adapter 注入。
+ */
+export class ProjectAccessTokenCache {
+    #entries = new Map();
+    #now;
+    #random;
+    #onRefreshDeferred;
+    constructor(options = {}) {
+        this.#now = options.now ?? Date.now;
+        this.#random = options.random ?? Math.random;
+        this.#onRefreshDeferred = options.onRefreshDeferred;
+    }
+    async resolve(scope, issue, rejectedFingerprint) {
+        const key = scopeKey(scope);
+        let entry = this.#entries.get(key);
+        // 仅清理被拒绝的那一代 PAT；迟到的 401 不得废弃新凭据或打断正在进行的换证。
+        if (rejectedFingerprint && entry?.fingerprint === rejectedFingerprint) {
+            entry.value = undefined;
+            entry.refreshAt = undefined;
+        }
+        if (entry?.pending)
+            return entry.pending;
+        if (entry?.value && this.#now() < Math.min(entry.refreshAt, entry.value.expiresAt)) {
+            return entry.value;
+        }
+        if (!entry) {
+            entry = {};
+            this.#entries.set(key, entry);
+        }
+        const current = entry;
+        const startedAt = this.#now();
+        // 延迟到微任务执行签发，先登记 pending，确保同步重入也只生成一个请求。
+        const pending = Promise.resolve()
+            .then(() => {
+            // 退出可能先于签发微任务发生；此时连旧登录态的网络请求也不得发出。
+            if (this.#entries.get(key) !== current) {
+                throw new ProjectAccessTokenError("project_token_scope_invalidated");
+            }
+            return issue();
+        })
+            .then(async (raw) => {
+            if (this.#entries.get(key) !== current) {
+                throw new ProjectAccessTokenError("project_token_scope_invalidated");
+            }
+            const response = responseSchema.safeParse(raw);
+            if (!response.success)
+                throw new ProjectAccessTokenError("project_token_invalid_response");
+            const data = response.data.data;
+            if (!data.enable) {
+                this.#entries.delete(key);
+                return Object.freeze({ enabled: false });
+            }
+            // expiresIn 从发出签发请求时保守起算，不能把网络耗时变成额外有效期。
+            const expiresAt = Math.min(data.expiresAt * SECOND_MS, startedAt + data.expiresIn * SECOND_MS);
+            if (!Number.isFinite(expiresAt) || expiresAt <= this.#now()) {
+                throw new ProjectAccessTokenError("project_token_invalid_response");
+            }
+            const jitter = Math.max(0, Math.min(1, this.#random())) * REFRESH_JITTER_MS;
+            const fingerprint = await projectAccessTokenFingerprint(data.accessToken);
+            if (this.#entries.get(key) !== current)
+                throw new ProjectAccessTokenError("project_token_scope_invalidated");
+            current.fingerprint = fingerprint;
+            current.value = Object.freeze({
+                enabled: true,
+                token: data.accessToken,
+                expiresAt,
+            });
+            current.refreshAt = expiresAt - REFRESH_LEAD_MS - jitter;
+            return current.value;
+        })
+            .catch((error) => {
+            if (this.#entries.get(key) !== current)
+                throw new ProjectAccessTokenError("project_token_scope_invalidated");
+            // 只保留仍有效且未被 401 指纹清除的 PAT；认证拒绝和格式错误必须失败。
+            // 降级属于同一个 pending，使所有并发调用获得一致结果，不延长原有效期。
+            if (error instanceof ProjectAccessTokenTransientError &&
+                current.value &&
+                this.#now() < current.value.expiresAt) {
+                current.refreshAt = Math.min(this.#now() + REFRESH_RETRY_BACKOFF_MS, current.value.expiresAt);
+                this.#onRefreshDeferred?.();
+                return current.value;
+            }
+            this.#entries.delete(key);
+            throw error;
+        })
+            .finally(() => {
+            if (current.pending === pending)
+                current.pending = undefined;
+        });
+        current.pending = pending;
+        return pending;
+    }
+    invalidate(scope) {
+        this.#entries.delete(scopeKey(scope));
+    }
+    clear() {
+        this.#entries.clear();
+    }
+}
+/** 仅用于拒绝某一代 PAT 的比较，不作为账号身份，也不传给模型上游。 */
+export async function projectAccessTokenFingerprint(token) {
+    const digest = await globalThis.crypto.subtle.digest("SHA-256", new TextEncoder().encode(token));
+    return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function scopeKey(scope) {
+    return JSON.stringify([
+        scope.origin,
+        scope.family,
+        scope.accountId,
+        scope.organizationId,
+        scope.projectId,
+        scope.apiKeyId,
+        scope.usageScene,
+        scope.loginGeneration,
+    ]);
+}
+//# sourceMappingURL=project-access-token.js.map

package/node_modules/@dcode/shared/dist/protocol.d.ts

@@ -2,7 +2,9 @@ import type { RemoteAssetInstallMode } from "./remoteAssetInstallMode.js";
 import type { RemoteResourcePackageSelection } from "./remoteResourcePackages.js";
 import type { ProviderFamilyDomain } from "./model-provider-family.js";
 import type { ProviderFamilyConnectionSelectionSettings } from "./provider-family-connection-selection.js";
+import type { DCodeProvider } from "./dcode-task-types-core.js";
 import type { WorkspacePurpose } from "./workspacePurpose.js";
+import type { DynamicWorkflowMode } from "./dynamic-workflow-feature.js";
 import type { EmbeddedBrowserViewportPreference } from "./browser-use/command-metadata.js";
 export interface FileEntry {
     name: string;
@@ -59,8 +61,8 @@ export interface SystemInfo {
     homedir: string;
     platform: string;
 }
-/** 支持的语言 */
-export type Locale = "zh-CN" | "en-US";
+/** 支持的语言（DipoleML 品牌语言面：英语 + 法语） */
+export type Locale = "fr-CA" | "en-US";
 /** 界面语言偏好；system 表示跟随当前运行端系统语言。 */
 export type LocalePreference = "system" | Locale;
 /** DCode 运行中继续输入时的交互行为 */
@@ -129,7 +131,19 @@ export interface DockerRemoteTargetSnapshot {
     kind: "docker";
     container: string;
 }
-export type RemoteTargetSnapshot = SSHRemoteTargetSnapshot | WSLRemoteTargetSnapshot | DockerRemoteTargetSnapshot;
+export interface ServerRemoteTargetSnapshot {
+    kind: "server";
+    url: string;
+    name?: string;
+    workspacePath?: string;
+    serverId?: string;
+    /**
+     * Server token 不写入 setting.json。
+     * 这里只保存 credentialService 的键名，恢复时再读取真实 token。
+     */
+    tokenCredentialKey?: string;
+}
+export type RemoteTargetSnapshot = SSHRemoteTargetSnapshot | WSLRemoteTargetSnapshot | DockerRemoteTargetSnapshot | ServerRemoteTargetSnapshot;
 export interface RemoteWorkspaceSessionSnapshot {
     /** 远程 workspace 的真实绝对路径 */
     workspacePath: string;
@@ -232,12 +246,18 @@ export interface AppSettings {
     taskAutoArchiveEnabled?: boolean;
     /** 自动归档阈值；当任务最后更新时间早于该天数时允许被归档 */
     taskAutoArchiveOlderThanDays?: number;
-    /** Windows 桌面端关闭窗口时隐藏到托盘；其它平台忽略 */
+    /** 桌面端关闭窗口时隐藏到托盘驻留（Windows/Linux；spec：docs/desktop/linux-close-to-tray.md） */
     closeToTrayOnWindows?: boolean;
     /** 存在执行中的闲时任务时阻止系统闲置休眠（手动开关，防不了合盖）。 */
     keepAwakeWhileRunning?: boolean;
     /** Windows 关闭到托盘默认值是否已执行过一次性迁移；只用于设置迁移，不参与业务判断。 */
     closeToTrayOnWindowsMigrationInitialized?: boolean;
+    /**
+     * Linux 关闭到托盘默认值（关）是否已执行过一次性归位迁移。
+     * shared 迁移无平台概念、曾把存量 Linux 用户归为 true，而 Linux 此前无设置入口，
+     * main 进程 bootstrap 借此标记把首次启动的 Linux 用户一次性归位为默认关。
+     */
+    closeToTrayLinuxMigrationInitialized?: boolean;
     /** 桌面端全局页面缩放档位；用于重启后恢复界面缩放，Web/手机端忽略。 */
     desktopZoomLevel?: number;
     /** 桌面主窗口最近一次非最大化宽高及最大化状态；Web/手机端忽略。 */
@@ -266,6 +286,13 @@ export interface AppSettings {
     askUserQuestionAutoResolutionEnabled?: boolean;
     /** 是否完整保留 Model I/O；开启后不轮转、不限额重置、不压缩或裁剪，鉴权信息仍会脱敏。 */
     modelIoFullRetentionEnabled?: boolean;
+    /**
+     * 用户选的动态工作流模式（docs/dynamic-workflow/launch.md「The user's choice」）。缺席 = 跟随服务端
+     * 提供的模式；只在功能已提供时生效。选回提供的模式时删除该字段，未改动的安装继续跟随服务端翻转。
+     */
+    dynamicWorkflowMode?: DynamicWorkflowMode;
+    /** 已启用的内置 Agent CLI；UI 对外仍展示为“Install”，底层语义保持为启用内置能力。 */
+    enabledBuiltinAgentCliProviders?: DCodeProvider[];
     /** 设置页中每个 Provider Family 当前唯一的结构化连接选择。 */
     providerFamilyConnectionSelections?: ProviderFamilyConnectionSelectionSettings;
     /**
@@ -312,6 +339,16 @@ export interface AppSettings {
     skippedElectronUpdateVersions?: Partial<Record<ElectronReleaseChannel, string>>;
     /** 首次启动设置同步提示是否已消费；只表示弹窗不再出现，不代表导入成功。 */
     settingsSyncFirstRunPromptHandled?: boolean;
+    /** 外部 Web 远控 relay 的非敏感设备身份；passHash 必须存 credentialService。 */
+    webRemoteControlExternalRelayDevice?: {
+        deviceSid: string;
+    };
+    /** 上次成功开启 Web 远控时的目标；缺失表示用户已明确关闭，不自动恢复。 */
+    webRemoteControlLastEnabledContext?: {
+        workspacePath: string;
+        workspaceIdentity?: string;
+        initialTaskId?: string;
+    };
     /** 设置页里的临时 endpoint override；正式/测试默认 base url 由 DCODE_BASE_URL env 管理。 */
     dcodeEndpointOrigin?: string;
 }

package/node_modules/@dcode/shared/dist/protocol.js

@@ -1,3 +1,3 @@
 /** 默认语言 */
-export const DEFAULT_LOCALE = "zh-CN";
+export const DEFAULT_LOCALE = "en-US";
 //# sourceMappingURL=protocol.js.map