修复记忆处理中误报失败提醒

.github/workflows/runtime-artifacts.yml

@@ -0,0 +1,101 @@
+name: Agent and Memory runtime artifacts
+run-name: runtime-artifacts-${{ github.ref_name }}
+
+on:
+  workflow_dispatch:
+    inputs:
+      runtime:
+        description: Runtime packages to build
+        type: choice
+        options: [both, memory]
+        default: both
+  push:
+    branches: [zy_memory_runtime_*]
+permissions:
+  contents: read
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - target: darwin-arm64
+            runner: macos-14
+            arch: arm64
+          - target: darwin-x64
+            runner: macos-15-intel
+            arch: x64
+          - target: linux-arm64
+            runner: ubuntu-24.04-arm
+            arch: arm64
+          - target: linux-x64
+            runner: ubuntu-24.04
+            arch: x64
+          - target: windows-arm64
+            runner: windows-11-arm
+            arch: arm64
+          - target: windows-x64
+            runner: windows-2025
+            arch: x64
+    runs-on: ${{ matrix.runner }}
+    timeout-minutes: 45
+    defaults:
+      run:
+        shell: bash
+    env:
+      COPYFILE_DISABLE: '1'
+      PLAYWRIGHT_SKIP_BROWSER_DOWNLOAD: '1'
+      ELECTRON_SKIP_BINARY_DOWNLOAD: '1'
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 26.0.0
+          architecture: ${{ matrix.arch }}
+          cache: npm
+      - name: Install build dependencies
+        run: npm ci --no-audit --no-fund
+      - name: Install Agent build dependencies
+        if: github.event_name == 'workflow_dispatch' && inputs.runtime != 'memory'
+        run: npm --prefix App/memmy-agent install --ignore-scripts --no-audit --no-fund
+      - name: Build Agent runtime
+        if: github.event_name == 'workflow_dispatch' && inputs.runtime != 'memory'
+        run: npm run agent:runtime:package -- --target "${{ matrix.target }}" --output "$RUNNER_TEMP/runtime-artifacts"
+      - name: Build Memory runtime
+        run: npm run runtime:package -w @memmy/memory -- --target "${{ matrix.target }}" --output "$RUNNER_TEMP/runtime-artifacts"
+      - name: Verify unpacked runtimes and native dependencies
+        run: node scripts/internal/shared/verify-runtime-artifacts.mjs "$RUNNER_TEMP/runtime-artifacts" "${{ matrix.target }}" "${{ inputs.runtime || 'memory' }}"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: runtimes-${{ matrix.target }}
+          path: ${{ runner.temp }}/runtime-artifacts/*
+          if-no-files-found: error
+          compression-level: 0
+          retention-days: 14
+
+  collect:
+    needs: build
+    runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 26.0.0
+      - uses: actions/download-artifact@v4
+        with:
+          pattern: runtimes-*
+          path: runtime-input
+      - name: Collect runtime archives with checksums
+        run: node scripts/internal/shared/collect-runtime-artifacts.mjs runtime-input runtime-output "${{ inputs.runtime || 'memory' }}"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: all-platform-runtimes
+          path: runtime-output/*
+          if-no-files-found: error
+          compression-level: 0
+          retention-days: 14

.gitignore

@@ -1,5 +1,6 @@
 node_modules/
 dist/
+App/memmy-agent/npm-packages/
 release/
 App/shell/desktop/release/
 Mac软件打包/

App/backend/local-api-contracts/src/index.ts

@@ -1127,6 +1127,8 @@ export type MemoryRuntimeModelSettings = z.infer<typeof MemoryRuntimeModelSettin
 
 /** Schema for model config view. */
 export const ModelConfigViewSchema = z.object({
+    /** Write-response-only aliases, resolved by the server using real credentials. */
+    endpointAliases: z.record(z.string(), z.record(z.string(), z.string())).optional(),
     configRevision: z.string().min(1),
     providers: z.array(TextModelProviderViewSchema),
     modelAssignments: ModelAssignmentsSchema,

App/backend/src/adapters/outbound/cloud-client/http-cloud-client.ts

@@ -68,6 +68,7 @@ import type {
 } from "./types.js";
 
 const DEFAULT_TIMEOUT_MS = 5_000;
+const CLOUD_SOCIAL_LOGIN_TIMEOUT_MS = 20_000;
 const CLOUD_COMPOSIO_ROUTER_TIMEOUT_MS = 60_000;
 const CLOUD_COMPOSIO_UNAVAILABLE_MESSAGE = "工具连接服务暂时不可用";
 const CLOUD_COMPOSIO_SERVICE_UNAVAILABLE_CODE = 60020;
@@ -147,7 +148,7 @@ export function createHttpCloudClient(options: CreateHttpCloudClientOptions = {}
       const data = await requestCloudData<Record<string, unknown>>(
         fetchImpl,
         baseUrl,
-        timeoutMs,
+        socialLoginTimeoutMs(timeoutMs),
         "/api/agentUser/oauth/start",
         {
           body: {
@@ -169,7 +170,7 @@ export function createHttpCloudClient(options: CreateHttpCloudClientOptions = {}
       const data = await requestCloudData<Record<string, unknown>>(
         fetchImpl,
         baseUrl,
-        timeoutMs,
+        socialLoginTimeoutMs(timeoutMs),
         "/api/agentUser/oauth/status",
         {
           body: { flowId: input.flowId, pollToken: input.pollToken },
@@ -532,6 +533,10 @@ async function requestCloudData<T>(
   return envelope.data as T;
 }
 
+function socialLoginTimeoutMs(timeoutMs: number): number {
+  return Math.max(timeoutMs, CLOUD_SOCIAL_LOGIN_TIMEOUT_MS);
+}
+
 function normalizeAgentRegion(value: string | undefined): "cn" | "intl" {
   return value?.trim().toLowerCase() === "intl" ? "intl" : "cn";
 }

App/backend/src/adapters/outbound/cloud-client/tests/cloud-client.test.ts

@@ -222,6 +222,39 @@ describe("cloud client", () => {
     ]);
   });
 
+  it("keeps waiting for Google login after the default cloud timeout", async () => {
+    server = createServer((_request, response) => {
+      setTimeout(() => {
+        sendJson(response, {
+          code: 0,
+          message: "ok",
+          data: {
+            flowId: "social-flow-id-0001",
+            pollToken: "social-poll-token-0000000000000001",
+            authorizationUrl: "https://accounts.google.com/o/oauth2/v2/auth?state=opaque-state",
+            expiresInSec: 600,
+            pollIntervalSec: 2
+          }
+        });
+      }, 1_500);
+    });
+    await listen(server);
+    const address = server.address();
+    if (!address || typeof address === "string") throw new Error("Mock cloud server did not bind");
+    const client = createHttpCloudClient({
+      baseUrl: `http://127.0.0.1:${address.port}`,
+      timeoutMs: 200
+    });
+
+    const start = await client.startSocialLogin({
+      provider: "google",
+      locale: "en",
+      loginSource: "Memmy"
+    });
+
+    expect(start.authorizationUrl).toContain("https://accounts.google.com/");
+  });
+
   it("rejects a social-login authorization URL outside the provider allowlist", async () => {
     server = createServer((_request, response) => {
       sendJson(response, {

App/backend/src/adapters/outbound/skill-writer/codex/hook-trust.ts

@@ -1,6 +1,7 @@
 /** Codex hook trust persistence through the Codex app-server protocol. */
 import { spawn, type ChildProcessWithoutNullStreams } from "node:child_process";
 import { accessSync, constants, statSync } from "node:fs";
+import { homedir } from "node:os";
 import { basename, join, normalize } from "node:path";
 
 const APP_SERVER_REQUEST_TIMEOUT_MS = 10_000;
@@ -283,8 +284,17 @@ function handleResponseLine(line: string, pending: Map<number, PendingRequest>):
 
 function resolveCodexExecutable(codexHomeDirectory: string): string {
   const executableName = process.platform === "win32" ? "codex.exe" : "codex";
-  const bundledExecutable = join(codexHomeDirectory, "plugins", ".plugin-appserver", executableName);
-  return isExecutableFile(bundledExecutable) ? bundledExecutable : executableName;
+  const candidates = [join(codexHomeDirectory, "plugins", ".plugin-appserver", executableName)];
+  if (process.platform === "darwin") {
+    // The desktop process may not inherit the shell PATH where ChatGPT exposes Codex CLI.
+    const codexCliPath = join("Contents", "Resources", "codex-cli", "CodexCLI.app", "Contents", "MacOS", "codex");
+    candidates.push(
+      join("/Applications", "ChatGPT.app", codexCliPath),
+      join(homedir(), "Applications", "ChatGPT.app", codexCliPath)
+    );
+  }
+
+  return candidates.find(isExecutableFile) ?? executableName;
 }
 
 function isExecutableFile(filePath: string): boolean {

App/backend/src/adapters/outbound/skill-writer/codex/target.ts

@@ -1,5 +1,5 @@
 /** Target module. */
-import { mkdir, readFile, rename, rm, stat, writeFile } from "node:fs/promises";
+import { lstat, mkdir, readFile, readlink, rename, rm, stat, symlink, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { basename, dirname, join } from "node:path";
 import { resolveCodexHomeDirectory } from "../../agent-paths.js";
@@ -118,18 +118,26 @@ export function createCodexSkillTarget(deps: CreateCodexSkillTargetDeps = {}): S
         memmy_config_path: memmyConfigPath,
         ...(await readMemmyMemoryServiceConfig(memmyConfigPath))
       };
-      await mkdir(hookDirectory, { recursive: true });
-      await writeFileAtomically(hookConfigPath, `${JSON.stringify(hookConfig, null, 2)}\n`);
-      await writeFileAtomically(hookScriptPath, renderMemmyResumeHookScript({ source: CODEX_TARGET_ID, mode: "codex" }));
-      await writeFileAtomically(
-        join(hookDirectory, WORKSPACE_BRIDGE_FILE_NAME),
-        await loadMemmyWorkspaceBridgeRuntimeAsset()
-      );
       const hooksFilePath = join(root, HOOKS_FILE_NAME);
+      const bridgePath = join(hookDirectory, WORKSPACE_BRIDGE_FILE_NAME);
       const hookCommand = createNodeHookCommand(hookScriptPath);
-      await upsertCodexHookConfig(hooksFilePath, hookCommand);
-      await rm(join(root, HOOK_DIRECTORY_NAME, LEGACY_HOOK_SCRIPT_FILE_NAME), { force: true });
+      await withCodexHookFileRollback(
+        [hookConfigPath, hookScriptPath, bridgePath, hooksFilePath],
+        async () => {
+          await mkdir(hookDirectory, { recursive: true });
+          await writeFileAtomically(hookConfigPath, `${JSON.stringify(hookConfig, null, 2)}\n`);
+          await writeFileAtomically(hookScriptPath, renderMemmyResumeHookScript({ source: CODEX_TARGET_ID, mode: "codex" }));
+          await writeFileAtomically(bridgePath, await loadMemmyWorkspaceBridgeRuntimeAsset());
+          await upsertCodexHookConfig(hooksFilePath, hookCommand);
+          await trustHooks({ codexHomeDirectory: root, hooksFilePath, hookCommand });
+          await writeFileAtomically(
+            hookConfigPath,
+            `${JSON.stringify({ ...hookConfig, ...(await memmyHookRevisionField(CODEX_TARGET_ID, "codex")) }, null, 2)}\n`
+          );
+        }
+      );
 
+      await rm(join(hookDirectory, LEGACY_HOOK_SCRIPT_FILE_NAME), { force: true });
       const manifest = renderMemmyPluginSkillManifest(_targetId);
       const filePath = join(root, TARGET_FILE_NAME);
       await writeFileAtomically(
@@ -138,15 +146,6 @@ export function createCodexSkillTarget(deps: CreateCodexSkillTargetDeps = {}): S
       );
       await replaceMemmySkillDirectory(root, manifest);
       await replaceMemmyResumeSkillDirectory(root, CODEX_TARGET_ID);
-      await trustHooks({
-        codexHomeDirectory: root,
-        hooksFilePath,
-        hookCommand
-      });
-      await writeFileAtomically(
-        hookConfigPath,
-        `${JSON.stringify({ ...hookConfig, ...(await memmyHookRevisionField(CODEX_TARGET_ID, "codex")) }, null, 2)}\n`
-      );
     },
 
     async uninstallPlugin(_targetId) {
@@ -335,11 +334,73 @@ function createMarkerBlockPattern(startMarker: string, endMarker = END_MARKER):
   return new RegExp(`${escapeRegExp(startMarker)}\\n[\\s\\S]*?${escapeRegExp(endMarker)}\\n?`, "m");
 }
 
-async function writeFileAtomically(filePath: string, content: string): Promise<void> {
+async function writeFileAtomically(filePath: string, content: string | Buffer, mode?: number): Promise<void> {
   await mkdir(dirname(filePath), { recursive: true });
   const tempPath = join(dirname(filePath), `.${basename(filePath)}.${process.pid}.${Date.now()}.tmp`);
-  await writeFile(tempPath, content, "utf8");
-  await rename(tempPath, filePath);
+  try {
+    await writeFile(tempPath, content, { encoding: "utf8", ...(mode === undefined ? {} : { mode }) });
+    await rename(tempPath, filePath);
+  } finally {
+    await rm(tempPath, { force: true });
+  }
+}
+
+type CodexHookFileSnapshot =
+  | { path: string; kind: "missing" }
+  | { path: string; kind: "file"; content: Buffer; mode: number }
+  | { path: string; kind: "symlink"; target: string };
+
+async function withCodexHookFileRollback<T>(paths: string[], operation: () => Promise<T>): Promise<T> {
+  const snapshots = await Promise.all(paths.map(snapshotCodexHookFile));
+  try {
+    return await operation();
+  } catch (error) {
+    const rollbackResults = await Promise.allSettled(snapshots.map(restoreCodexHookFile));
+    const rollbackErrors = rollbackResults.flatMap((result) => result.status === "rejected" ? [result.reason] : []);
+    if (rollbackErrors.length > 0) {
+      throw new AggregateError(
+        [error, ...rollbackErrors],
+        "Codex hook installation failed and its files could not be fully rolled back"
+      );
+    }
+
+    throw error;
+  }
+}
+
+async function snapshotCodexHookFile(filePath: string): Promise<CodexHookFileSnapshot> {
+  try {
+    const metadata = await lstat(filePath);
+    if (metadata.isSymbolicLink()) {
+      return { path: filePath, kind: "symlink", target: await readlink(filePath) };
+    }
+    if (!metadata.isFile()) {
+      throw new Error(`Codex hook path is not a regular file: ${filePath}`);
+    }
+
+    return { path: filePath, kind: "file", content: await readFile(filePath), mode: metadata.mode & 0o777 };
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return { path: filePath, kind: "missing" };
+    }
+
+    throw error;
+  }
+}
+
+async function restoreCodexHookFile(snapshot: CodexHookFileSnapshot): Promise<void> {
+  if (snapshot.kind === "missing") {
+    await rm(snapshot.path, { force: true });
+    return;
+  }
+
+  if (snapshot.kind === "symlink") {
+    await rm(snapshot.path, { force: true });
+    await symlink(snapshot.target, snapshot.path);
+    return;
+  }
+
+  await writeFileAtomically(snapshot.path, snapshot.content, snapshot.mode);
 }
 
 function escapeRegExp(input: string): string {