@tablestore/tablestore-agent-cli 0.2.11 → 0.4.0

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/_scope.ts

@@ -1,5 +1,72 @@
 import type { MemoryScope } from "@tablestore/tablestore-agent-shared";
 
+export interface ExactMemoryScope {
+  appId: string;
+  tenantId: string;
+  agentId: string;
+  runId: string;
+}
+
+export interface AgentWikiScope {
+  appId: string;
+  tenantId: string;
+  agentId: string;
+}
+
+export function readAgentWikiScope(raw: unknown): AgentWikiScope | null {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+
+  const value = raw as Record<string, unknown>;
+  const read = (key: keyof AgentWikiScope) => {
+    const component = value[key];
+    if (typeof component !== "string") return null;
+    const normalized = component.trim();
+    return normalized && normalized !== "*" ? normalized : null;
+  };
+
+  const appId = read("appId");
+  const tenantId = read("tenantId");
+  const agentId = read("agentId");
+  if (!appId || !tenantId || !agentId) return null;
+
+  return { appId, tenantId, agentId };
+}
+
+export function toAgentWikiScope(
+  scope: AgentWikiScope | ExactMemoryScope,
+): AgentWikiScope {
+  return {
+    appId: scope.appId,
+    tenantId: scope.tenantId,
+    agentId: scope.agentId,
+  };
+}
+
+/**
+ * Read a concrete four-part Memory scope from an untrusted value.
+ *
+ * Point APIs must not widen missing components or accept wildcard segments.
+ */
+export function readExactMemoryScope(raw: unknown): ExactMemoryScope | null {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+
+  const value = raw as Record<string, unknown>;
+  const read = (key: keyof ExactMemoryScope) => {
+    const component = value[key];
+    if (typeof component !== "string") return null;
+    const normalized = component.trim();
+    return normalized && normalized !== "*" ? normalized : null;
+  };
+
+  const appId = read("appId");
+  const tenantId = read("tenantId");
+  const agentId = read("agentId");
+  const runId = read("runId");
+  if (!appId || !tenantId || !agentId || !runId) return null;
+
+  return { appId, tenantId, agentId, runId };
+}
+
 /**
  * Extract a {@link MemoryScope} from URL query parameters.
  *

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/dream-tasks/[dreamId]/actions/apply/route.ts

@@ -12,10 +12,9 @@ import {
 /**
  * POST /api/v1/memory/stores/:store/dream-tasks/:dreamId/actions/apply
  *
- * Apply the supplied action ids to the memory store. Body shape:
- *   { actionIds: string[]; applier?: string }
- * The route validates the actionIds shape locally so a malformed body
- * doesn't reach the engine's per-action retry loop.
+ * Apply selected actions or approve an Agentic Dream plan. Body shape:
+ *   { mode: "actions"; actionIds: string[]; applier?: string }
+ *   { mode: "plan"; approver: string }
  */
 interface RouteContext {
   params: Promise<{ store: string; dreamId: string }>;
@@ -39,22 +38,56 @@ export async function POST(request: NextRequest, context: RouteContext) {
       });
     }
 
+    if (body.mode === "plan") {
+      const approver =
+        typeof body.approver === "string" ? body.approver.trim() : "";
+      if (approver === "" || body.actionIds !== undefined) {
+        return forwardResponse({
+          code: "BAD_REQUEST",
+          data: null,
+          message:
+            "mode=plan requires a non-empty approver and must not carry actionIds",
+        });
+      }
+      const response = await memory.applyMemoryDreamActions({
+        memoryStoreName: store,
+        dreamId,
+        mode: "plan",
+        approver,
+      });
+      return forwardResponse(response);
+    }
+
+    if (body.mode !== "actions" && body.mode !== undefined) {
+      return forwardResponse({
+        code: "BAD_REQUEST",
+        data: null,
+        message: "mode must be actions or plan",
+      });
+    }
+
     const actionIds = body.actionIds;
     if (
       !Array.isArray(actionIds) ||
       actionIds.length === 0 ||
-      !actionIds.every((id) => typeof id === "string" && id.length > 0)
+      actionIds.length > 100 ||
+      !actionIds.every(
+        (id) => typeof id === "string" && id.trim().length > 0,
+      ) ||
+      body.approver !== undefined
     ) {
       return forwardResponse({
         code: "BAD_REQUEST",
         data: null,
-        message: "actionIds must be a non-empty array of non-empty strings",
+        message:
+          "mode=actions requires 1 to 100 non-empty actionIds and must not carry approver",
       });
     }
 
     const sdkRequest: Record<string, unknown> = {
       memoryStoreName: store,
       dreamId,
+      mode: "actions",
       actionIds,
     };
     if (typeof body.applier === "string" && body.applier) {

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/file-memory/[action]/route.ts

@@ -25,43 +25,37 @@ type Dispatcher = (
 ) => Promise<unknown>;
 
 const dispatchers: Record<string, Dispatcher> = {
-  list: (client, request) =>
-    client.listFileMemories(
-      request as unknown as Parameters<MemoryClient["listFileMemories"]>[0],
-    ),
-  stat: (client, request) =>
-    client.statFileMemory(
-      request as unknown as Parameters<MemoryClient["statFileMemory"]>[0],
+  add: (client, request) =>
+    client.addItem(
+      request as unknown as Parameters<MemoryClient["addItem"]>[0],
     ),
-  read: (client, request) =>
-    client.readFileMemory(
-      request as unknown as Parameters<MemoryClient["readFileMemory"]>[0],
+  list: (client, request) =>
+    client.listItems(
+      request as unknown as Parameters<MemoryClient["listItems"]>[0],
     ),
-  create: (client, request) =>
-    client.createFileMemory(
-      request as unknown as Parameters<MemoryClient["createFileMemory"]>[0],
+  get: (client, request) =>
+    client.getItem(
+      request as unknown as Parameters<MemoryClient["getItem"]>[0],
     ),
   update: (client, request) =>
-    client.updateFileMemory(
-      request as unknown as Parameters<MemoryClient["updateFileMemory"]>[0],
-    ),
-  rename: (client, request) =>
-    client.renameFileMemory(
-      request as unknown as Parameters<MemoryClient["renameFileMemory"]>[0],
+    client.updateItem(
+      request as unknown as Parameters<MemoryClient["updateItem"]>[0],
     ),
   delete: (client, request) =>
-    client.deleteFileMemory(
-      request as unknown as Parameters<MemoryClient["deleteFileMemory"]>[0],
+    client.deleteItem(
+      request as unknown as Parameters<MemoryClient["deleteItem"]>[0],
     ),
   "versions-list": (client, request) =>
-    client.listFileMemoryVersions(
-      request as unknown as Parameters<
-        MemoryClient["listFileMemoryVersions"]
-      >[0],
+    client.listItemVersions(
+      request as unknown as Parameters<MemoryClient["listItemVersions"]>[0],
+    ),
+  "version-get": (client, request) =>
+    client.getItemVersion(
+      request as unknown as Parameters<MemoryClient["getItemVersion"]>[0],
     ),
-  "versions-get": (client, request) =>
-    client.getFileMemoryVersion(
-      request as unknown as Parameters<MemoryClient["getFileMemoryVersion"]>[0],
+  "version-redact": (client, request) =>
+    client.redactItemVersion(
+      request as unknown as Parameters<MemoryClient["redactItemVersion"]>[0],
     ),
 };
 

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/file-memory/_helpers.ts

@@ -1,9 +1,7 @@
-export interface ExactFileMemoryScope {
-  appId: string;
-  tenantId: string;
-  agentId: string;
-  runId: string;
-}
+import { readExactMemoryScope, type ExactMemoryScope } from "../_scope";
+
+export { readExactMemoryScope } from "../_scope";
+export type ExactFileMemoryScope = ExactMemoryScope;
 
 /**
  * File APIs only accept a concrete four-part scope. Unlike structured-memory
@@ -12,21 +10,5 @@ export interface ExactFileMemoryScope {
 export function readExactFileMemoryScope(
   raw: unknown,
 ): ExactFileMemoryScope | null {
-  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
-
-  const value = raw as Record<string, unknown>;
-  const read = (key: "appId" | "tenantId" | "agentId" | "runId") => {
-    const component = value[key];
-    if (typeof component !== "string") return null;
-    const normalized = component.trim();
-    return normalized && normalized !== "*" ? normalized : null;
-  };
-
-  const appId = read("appId");
-  const tenantId = read("tenantId");
-  const agentId = read("agentId");
-  const runId = read("runId");
-  if (!appId || !tenantId || !agentId || !runId) return null;
-
-  return { appId, tenantId, agentId, runId };
+  return readExactMemoryScope(raw);
 }

package/dist/dashboard-runtime/dashboard/src/app/api/v1/memory/stores/[store]/wikis/_helpers.ts

@@ -0,0 +1,317 @@
+import type { AgentWikiScope } from "../_scope";
+import { readAgentWikiScope } from "../_scope";
+
+const MAX_NAME_BYTES = 256;
+const MAX_SUMMARY_BYTES = 4096;
+const MAX_CLIENT_TOKEN_BYTES = 256;
+const MAX_PAGE_PATH_BYTES = 1024;
+const MAX_DREAM_ACTION_REFS = 100;
+const CONTROL_CHARACTER_PATTERN = /\p{Cc}/u;
+
+export const SOURCE_EXTENSIONS = new Set([".md", ".txt"]);
+export const MAX_SOURCE_CONTENT_BYTES = 100 * 1024;
+const WIKI_SOURCE_ERROR_MESSAGE = "Wiki source operation failed";
+
+export interface PublicWikiSource {
+  path: string;
+  contentSha256: string;
+  contentSizeBytes: number;
+  latestVersionId: string;
+  createdAt: string;
+  updatedAt: string;
+  content?: string;
+}
+
+export interface WikiJsonBody extends Record<string, unknown> {
+  scope: AgentWikiScope;
+}
+
+export function sanitizeWikiSourceErrorResponse<
+  T extends { code: string; message: string },
+>(response: T): T {
+  return response.code === "SUCCESS"
+    ? response
+    : { ...response, message: WIKI_SOURCE_ERROR_MESSAGE };
+}
+
+export type OptionalValue<T> = { ok: true; value?: T } | { ok: false };
+
+export interface DreamActionRef {
+  dreamId: string;
+  actionId: string;
+}
+
+function utf8Length(value: string): number {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+function invalidRawSource(): never {
+  throw new Error("Invalid Wiki raw source");
+}
+
+export function toWikiRawItemPath(rawRelativePath: unknown): string {
+  if (typeof rawRelativePath !== "string") invalidRawSource();
+
+  const relativePath = rawRelativePath.normalize("NFC");
+  if (
+    !relativePath ||
+    relativePath.startsWith("/") ||
+    relativePath.endsWith("/") ||
+    relativePath.includes("\\") ||
+    relativePath.includes("\0")
+  ) {
+    invalidRawSource();
+  }
+
+  const segments = relativePath.split("/");
+  if (
+    segments.some((segment) => !segment || segment === "." || segment === "..")
+  ) {
+    invalidRawSource();
+  }
+
+  const fileName = segments.at(-1)!;
+  const dot = fileName.lastIndexOf(".");
+  const extension = dot < 0 ? "" : fileName.slice(dot).toLowerCase();
+  if (!SOURCE_EXTENSIONS.has(extension)) invalidRawSource();
+
+  const physicalPath = `/.wiki/raw/${relativePath}`;
+  if (utf8Length(physicalPath) > MAX_PAGE_PATH_BYTES) invalidRawSource();
+  return physicalPath;
+}
+
+export function fromWikiRawItemPath(rawPhysicalPath: unknown): string {
+  if (typeof rawPhysicalPath !== "string") invalidRawSource();
+
+  const prefix = "/.wiki/raw/";
+  if (!rawPhysicalPath.startsWith(prefix)) invalidRawSource();
+  const relativePath = rawPhysicalPath.slice(prefix.length);
+  if (toWikiRawItemPath(relativePath) !== rawPhysicalPath) {
+    invalidRawSource();
+  }
+  return relativePath;
+}
+
+export function assertWikiSourceContent(rawContent: unknown): string {
+  if (
+    typeof rawContent !== "string" ||
+    utf8Length(rawContent) > MAX_SOURCE_CONTENT_BYTES
+  ) {
+    throw new Error("Invalid Wiki raw source content");
+  }
+  return rawContent;
+}
+
+export function toPublicWikiSource(rawItem: unknown): PublicWikiSource {
+  if (!rawItem || typeof rawItem !== "object" || Array.isArray(rawItem)) {
+    invalidRawSource();
+  }
+  const item = rawItem as Record<string, unknown>;
+  if (
+    typeof item.contentSha256 !== "string" ||
+    typeof item.contentSizeBytes !== "number" ||
+    !Number.isFinite(item.contentSizeBytes) ||
+    item.contentSizeBytes < 0 ||
+    typeof item.latestVersionId !== "string" ||
+    !item.latestVersionId ||
+    typeof item.createdAt !== "string" ||
+    typeof item.updatedAt !== "string" ||
+    (item.content !== undefined && typeof item.content !== "string")
+  ) {
+    throw new Error("Invalid Memory Item response");
+  }
+  return {
+    path: fromWikiRawItemPath(item.path),
+    contentSha256: item.contentSha256,
+    contentSizeBytes: item.contentSizeBytes,
+    latestVersionId: item.latestVersionId,
+    createdAt: item.createdAt,
+    updatedAt: item.updatedAt,
+    ...(typeof item.content === "string" ? { content: item.content } : {}),
+  };
+}
+
+export function hasCallerWikiId(
+  request: Request,
+  body?: Record<string, unknown> | null,
+): boolean {
+  return (
+    new URL(request.url).searchParams.has("wikiId") ||
+    (body !== undefined &&
+      body !== null &&
+      Object.prototype.hasOwnProperty.call(body, "wikiId"))
+  );
+}
+
+export function hasCallerBuildId(
+  request: Request,
+  body?: Record<string, unknown> | null,
+): boolean {
+  return (
+    new URL(request.url).searchParams.has("buildId") ||
+    (body !== undefined &&
+      body !== null &&
+      Object.prototype.hasOwnProperty.call(body, "buildId"))
+  );
+}
+
+export function readExactScopeFromQuery(
+  params: URLSearchParams,
+): AgentWikiScope | null {
+  return readAgentWikiScope({
+    appId: params.get("appId"),
+    tenantId: params.get("tenantId"),
+    agentId: params.get("agentId"),
+  });
+}
+
+export async function readWikiJsonBody(
+  request: Request,
+): Promise<WikiJsonBody | null> {
+  let raw: unknown;
+  try {
+    raw = await request.json();
+  } catch {
+    return null;
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+
+  const body = raw as Record<string, unknown>;
+  const scope = readAgentWikiScope(body.scope);
+  return scope ? { ...body, scope } : null;
+}
+
+export function readWikiPagePath(raw: unknown): string | null {
+  if (typeof raw !== "string" || raw.includes("\\") || raw.includes("\0")) {
+    return null;
+  }
+
+  const path = raw;
+  if (
+    !path.startsWith("/wiki/") ||
+    !path.toLowerCase().endsWith(".md") ||
+    utf8Length(path) > MAX_PAGE_PATH_BYTES
+  ) {
+    return null;
+  }
+
+  const segments = path.split("/").slice(1);
+  if (
+    segments.some(
+      (segment) => segment.length === 0 || segment === "." || segment === "..",
+    )
+  ) {
+    return null;
+  }
+  return path;
+}
+
+export function readRequiredWikiName(raw: unknown): string | null {
+  if (typeof raw !== "string" || utf8Length(raw) > MAX_NAME_BYTES) return null;
+  const name = raw.trim();
+  return name || null;
+}
+
+export function readOptionalWikiName(raw: unknown): OptionalValue<string> {
+  if (raw === undefined) return { ok: true };
+  const name = readRequiredWikiName(raw);
+  return name === null ? { ok: false } : { ok: true, value: name };
+}
+
+export function readOptionalWikiSummary(raw: unknown): OptionalValue<string> {
+  if (raw === undefined) return { ok: true };
+  return typeof raw === "string" && utf8Length(raw) <= MAX_SUMMARY_BYTES
+    ? { ok: true, value: raw }
+    : { ok: false };
+}
+
+export function readOptionalClientToken(raw: unknown): OptionalValue<string> {
+  if (raw === undefined) return { ok: true };
+  if (
+    typeof raw !== "string" ||
+    !raw.trim() ||
+    utf8Length(raw) > MAX_CLIENT_TOKEN_BYTES
+  ) {
+    return { ok: false };
+  }
+  return { ok: true, value: raw };
+}
+
+export function readOptionalDreamActionRefs(
+  raw: unknown,
+): OptionalValue<DreamActionRef[]> {
+  if (raw === undefined) return { ok: true };
+  if (!Array.isArray(raw) || raw.length > MAX_DREAM_ACTION_REFS) {
+    return { ok: false };
+  }
+
+  const refs: DreamActionRef[] = [];
+  const seen = new Set<string>();
+  for (const value of raw) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return { ok: false };
+    }
+    const record = value as Record<string, unknown>;
+    if (
+      typeof record.dreamId !== "string" ||
+      typeof record.actionId !== "string"
+    ) {
+      return { ok: false };
+    }
+    const normalizedDreamId = record.dreamId.trim();
+    const normalizedActionId = record.actionId.trim();
+    if (
+      !normalizedDreamId ||
+      !normalizedActionId ||
+      utf8Length(record.dreamId) > 128 ||
+      utf8Length(record.actionId) > 128 ||
+      utf8Length(normalizedDreamId) > 128 ||
+      utf8Length(normalizedActionId) > 128 ||
+      CONTROL_CHARACTER_PATTERN.test(normalizedDreamId + normalizedActionId)
+    ) {
+      return { ok: false };
+    }
+    const key = `${normalizedDreamId}\0${normalizedActionId}`;
+    if (seen.has(key)) return { ok: false };
+    seen.add(key);
+    refs.push({
+      dreamId: normalizedDreamId,
+      actionId: normalizedActionId,
+    });
+  }
+  return { ok: true, value: refs };
+}
+
+export function readOptionalQueryLimit(
+  raw: string | null,
+): OptionalValue<number> {
+  if (raw === null) return { ok: true };
+  if (!/^\d+$/.test(raw)) return { ok: false };
+  const limit = Number(raw);
+  return Number.isInteger(limit) && limit >= 1 && limit <= 100
+    ? { ok: true, value: limit }
+    : { ok: false };
+}
+
+export function readOptionalJsonLimit(raw: unknown): OptionalValue<number> {
+  if (raw === undefined) return { ok: true };
+  return typeof raw === "number" &&
+    Number.isInteger(raw) &&
+    raw >= 1 &&
+    raw <= 100
+    ? { ok: true, value: raw }
+    : { ok: false };
+}
+
+export function readOptionalNextToken(
+  raw: string | null,
+): OptionalValue<string> {
+  if (raw === null) return { ok: true };
+  return raw.trim() ? { ok: true, value: raw } : { ok: false };
+}
+
+export function readRequiredSearchQuery(raw: unknown): string | null {
+  if (typeof raw !== "string") return null;
+  const query = raw.trim();
+  return query || null;
+}