aws-runtime-bridge 1.7.33 → 1.7.34

package/dist/index.js

@@ -18,6 +18,7 @@ import { mcpRouter } from "./routes/mcp.js";
 import { terminalRouter, sdkSessions } from "./routes/terminal.js";
 import { sessionsRouter } from "./routes/sessions.js";
 import { gitRouter } from "./routes/git.js";
+import { memoryRouter } from "./routes/memory.js";
 import { fileBrowserRouter } from "./routes/file-browser.js";
 import { aiSourcesRouter } from "./routes/ai-sources.js";
 import { processesRouter } from "./routes/processes.js";
@@ -270,6 +271,7 @@ app.use("/runtime", sessionsRouter);
 app.use("/runtime", processesRouter);
 app.use("/runtime", systemMetricsRouter);
 app.use("/runtime", gitRouter);
+app.use("/runtime", memoryRouter);
 app.use("/runtime", aiSourcesRouter);
 app.use("/pty", ptyRouter);
 app.use("/api/file-browser", fileBrowserRouter);

package/dist/routes/memory-route-wiring.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=memory-route-wiring.test.d.ts.map

package/dist/routes/memory-route-wiring.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-route-wiring.test.d.ts","sourceRoot":"","sources":["../../src/routes/memory-route-wiring.test.ts"],"names":[],"mappings":""}

package/dist/routes/memory-route-wiring.test.js

@@ -0,0 +1,15 @@
+import { readFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+const currentDir = dirname(fileURLToPath(import.meta.url));
+const srcDir = resolve(currentDir, "..");
+describe("memory route wiring", () => {
+    it("mounts the authenticated memory list route under /runtime", () => {
+        const routeSource = readFileSync(resolve(currentDir, "./memory.ts"), "utf-8");
+        const indexSource = readFileSync(resolve(srcDir, "./index.ts"), "utf-8");
+        expect(routeSource).toMatch(/memoryRouter\.post\(\s*"\/memory\/list",\s*validateToken/);
+        expect(indexSource).toContain('import { memoryRouter } from "./routes/memory.js";');
+        expect(indexSource).toContain('app.use("/runtime", memoryRouter);');
+    });
+});

package/dist/routes/memory.d.ts

@@ -0,0 +1,25 @@
+export declare const memoryRouter: import("express-serve-static-core").Router;
+type MemoryType = "task_list" | "recently_memory" | "memory";
+interface MemoryRecord {
+    id: string;
+    uri: string;
+    domain: string;
+    path: string;
+    content: string;
+    memory_type: MemoryType;
+    createdAt: string;
+    updatedAt: string;
+    version: number;
+}
+/**
+ * 解析永久记忆目录。
+ * 主流程：使用请求中的 Agent 工作区路径，定位该工作区下 .agentswork/memory/memory 分域 JSON 文件。
+ */
+export declare function resolvePermanentMemoryStorePath(workspacePath: string): string;
+/**
+ * 读取工作区永久记忆。
+ * 主流程：遍历 domain JSON -> 规范化记录 -> 仅返回 memory 类型并按更新时间倒序展示。
+ */
+export declare function listPermanentMemoriesFromWorkspace(workspacePath: string): Promise<MemoryRecord[]>;
+export {};
+//# sourceMappingURL=memory.d.ts.map

package/dist/routes/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../src/routes/memory.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,YAAY,4CAAW,CAAC;AAErC,KAAK,UAAU,GAAG,WAAW,GAAG,iBAAiB,GAAG,QAAQ,CAAC;AAE7D,UAAU,YAAY;IACpB,EAAE,EAAE,MAAM,CAAC;IACX,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,UAAU,CAAC;IACxB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;CACjB;AAQD;;;GAGG;AACH,wBAAgB,+BAA+B,CAAC,aAAa,EAAE,MAAM,GAAG,MAAM,CAY7E;AAgDD;;;GAGG;AACH,wBAAsB,kCAAkC,CACtD,aAAa,EAAE,MAAM,GACpB,OAAO,CAAC,YAAY,EAAE,CAAC,CAoCzB"}

package/dist/routes/memory.js

@@ -0,0 +1,98 @@
+import { Router } from "express";
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { validateToken } from "../middleware/auth.js";
+export const memoryRouter = Router();
+const URI_PATTERN = /^([a-zA-Z_][a-zA-Z0-9_]*):\/\/(.*)$/;
+/**
+ * 解析永久记忆目录。
+ * 主流程：使用请求中的 Agent 工作区路径，定位该工作区下 .agentswork/memory/memory 分域 JSON 文件。
+ */
+export function resolvePermanentMemoryStorePath(workspacePath) {
+    const normalizedWorkspacePath = String(workspacePath || "").trim();
+    if (!normalizedWorkspacePath) {
+        throw new Error("workspacePath is required");
+    }
+    return path.join(path.normalize(normalizedWorkspacePath), ".agentswork", "memory", "memory");
+}
+function normalizeUri(input) {
+    const matched = URI_PATTERN.exec(String(input || "").trim());
+    if (!matched) {
+        throw new Error(`Invalid memory uri: ${input}`);
+    }
+    const domain = matched[1]?.toLowerCase();
+    const normalizedPath = (matched[2] || "").replace(/^\/+|\/+$/g, "");
+    if (!domain || !normalizedPath) {
+        throw new Error(`Invalid memory uri: ${input}`);
+    }
+    return {
+        uri: `${domain}://${normalizedPath}`,
+        domain,
+        path: normalizedPath,
+    };
+}
+function normalizeMemoryRecord(uri, record) {
+    const memoryType = record.memory_type || "memory";
+    if (memoryType !== "memory") {
+        return null;
+    }
+    const normalized = normalizeUri(record.uri || uri);
+    return {
+        id: String(record.id || normalized.uri),
+        uri: normalized.uri,
+        domain: normalized.domain,
+        path: normalized.path,
+        content: String(record.content || ""),
+        memory_type: "memory",
+        createdAt: String(record.createdAt || record.updatedAt || ""),
+        updatedAt: String(record.updatedAt || record.createdAt || ""),
+        version: typeof record.version === "number" ? record.version : 1,
+    };
+}
+/**
+ * 读取工作区永久记忆。
+ * 主流程：遍历 domain JSON -> 规范化记录 -> 仅返回 memory 类型并按更新时间倒序展示。
+ */
+export async function listPermanentMemoriesFromWorkspace(workspacePath) {
+    const storePath = resolvePermanentMemoryStorePath(workspacePath);
+    let entries;
+    try {
+        entries = await fs.readdir(storePath);
+    }
+    catch (error) {
+        const err = error;
+        if (err.code === "ENOENT") {
+            return [];
+        }
+        throw new Error(`memory store is not accessible: ${storePath}${err.message ? ` (${err.message})` : ""}`);
+    }
+    const records = [];
+    for (const entry of entries) {
+        if (!entry.endsWith(".json")) {
+            continue;
+        }
+        const filePath = path.join(storePath, entry);
+        const raw = await fs.readFile(filePath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const byUri = parsed.by_uri && typeof parsed.by_uri === "object" ? parsed.by_uri : {};
+        for (const [uri, record] of Object.entries(byUri)) {
+            const normalized = normalizeMemoryRecord(uri, record);
+            if (normalized) {
+                records.push(normalized);
+            }
+        }
+    }
+    records.sort((left, right) => right.updatedAt.localeCompare(left.updatedAt));
+    return records;
+}
+memoryRouter.post("/memory/list", validateToken, async (req, res) => {
+    try {
+        const workspacePath = String(req.body?.workspacePath || "");
+        const records = await listPermanentMemoriesFromWorkspace(workspacePath);
+        res.json(records);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        res.status(400).json({ error: message });
+    }
+});

package/dist/routes/memory.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=memory.test.d.ts.map

package/dist/routes/memory.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.test.d.ts","sourceRoot":"","sources":["../../src/routes/memory.test.ts"],"names":[],"mappings":""}

package/dist/routes/memory.test.js

@@ -0,0 +1,48 @@
+import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { listPermanentMemoriesFromWorkspace, resolvePermanentMemoryStorePath, } from "./memory.js";
+describe("runtime permanent memory route helpers", () => {
+    it("resolves permanent memory under the agent workspace", () => {
+        expect(resolvePermanentMemoryStorePath("/workspace/project").replace(/\\/g, "/")).toBe("/workspace/project/.agentswork/memory/memory");
+    });
+    it("lists only permanent memory records from workspace-local domain files", async () => {
+        const workspacePath = await mkdtemp(path.join(os.tmpdir(), "aws-memory-workspace-"));
+        const storePath = resolvePermanentMemoryStorePath(workspacePath);
+        await mkdir(storePath, { recursive: true });
+        await writeFile(path.join(storePath, "core.json"), JSON.stringify({
+            by_uri: {
+                "core://agent/profile": {
+                    id: "m-1",
+                    uri: "Core://agent/profile/",
+                    content: "profile",
+                    memory_type: "memory",
+                    createdAt: "2026-01-01T00:00:00.000Z",
+                    updatedAt: "2026-01-02T00:00:00.000Z",
+                    version: 2,
+                },
+                "core://task/current": {
+                    id: "t-1",
+                    uri: "core://task/current",
+                    content: "task",
+                    memory_type: "task_list",
+                    createdAt: "2026-01-01T00:00:00.000Z",
+                    updatedAt: "2026-01-03T00:00:00.000Z",
+                    version: 1,
+                },
+            },
+        }), "utf-8");
+        const records = await listPermanentMemoriesFromWorkspace(workspacePath);
+        expect(records).toHaveLength(1);
+        expect(records[0]).toMatchObject({
+            id: "m-1",
+            uri: "core://agent/profile",
+            domain: "core",
+            path: "agent/profile",
+            content: "profile",
+            memory_type: "memory",
+            version: 2,
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "aws-runtime-bridge",
-  "version": "1.7.33",
+  "version": "1.7.34",
   "description": "AgentsWorkStudio runtime bridge service for machine-level agent runtime integration",
   "type": "module",
   "main": "dist/index.js",