@tablestore/tablestore-agent-cli 0.2.11 → 0.3.1

package/dist/dashboard-runtime/dashboard/src/lib/memory-scope-history.ts

@@ -0,0 +1,165 @@
+import type { MemoryScope } from "@/types/memory";
+
+export const MAX_RECENT_MEMORY_SCOPES = 10;
+const STORAGE_KEY_PREFIX = "tsagent.memoryScopes.v1";
+
+type ScopeStorage = Pick<Storage, "getItem" | "setItem" | "removeItem">;
+type OptionalScopeField = "tenantId" | "agentId" | "runId";
+
+const OPTIONAL_SCOPE_FIELDS: OptionalScopeField[] = [
+  "tenantId",
+  "agentId",
+  "runId",
+];
+
+export function getRecentMemoryScopeStorageKey(
+  dataScopeKey: string,
+  memoryStoreName: string,
+): string {
+  return `${STORAGE_KEY_PREFIX}:${JSON.stringify([dataScopeKey, memoryStoreName])}`;
+}
+
+export function isAllWildcardMemoryScope(
+  value: Partial<MemoryScope> | null | undefined,
+): boolean {
+  if (!value || typeof value.appId !== "string" || value.appId.trim() !== "*") {
+    return false;
+  }
+
+  return OPTIONAL_SCOPE_FIELDS.every((field) => {
+    const fieldValue = value[field];
+    if (fieldValue === undefined) return true;
+    if (typeof fieldValue !== "string") return false;
+    const normalized = fieldValue.trim();
+    return !normalized || normalized === "*";
+  });
+}
+
+export function normalizeRecentMemoryScope(
+  value: Partial<MemoryScope> | null | undefined,
+): MemoryScope | null {
+  if (!value || typeof value.appId !== "string" || !value.appId.trim()) {
+    return null;
+  }
+
+  const scope: MemoryScope = { appId: value.appId.trim() };
+  for (const field of OPTIONAL_SCOPE_FIELDS) {
+    const fieldValue = value[field];
+    if (typeof fieldValue === "string" && fieldValue.trim()) {
+      scope[field] = fieldValue.trim();
+    }
+  }
+
+  return isAllWildcardMemoryScope(scope) ? null : scope;
+}
+
+function scopeIdentity(scope: MemoryScope): string {
+  return JSON.stringify([
+    scope.appId,
+    scope.tenantId ?? "",
+    scope.agentId ?? "",
+    scope.runId ?? "",
+  ]);
+}
+
+export function readRecentMemoryScopes(
+  storage: Pick<ScopeStorage, "getItem">,
+  dataScopeKey: string,
+  memoryStoreName: string,
+): MemoryScope[] {
+  try {
+    const raw = storage.getItem(
+      getRecentMemoryScopeStorageKey(dataScopeKey, memoryStoreName),
+    );
+    if (!raw) return [];
+
+    const parsed = JSON.parse(raw) as unknown;
+    if (!Array.isArray(parsed)) return [];
+
+    const identities = new Set<string>();
+    const scopes: MemoryScope[] = [];
+    for (const item of parsed) {
+      const value =
+        item && typeof item === "object"
+          ? (item as Partial<MemoryScope>)
+          : null;
+      if (isAllWildcardMemoryScope(value)) continue;
+
+      const scope = normalizeRecentMemoryScope(value);
+      if (!scope) continue;
+
+      const identity = scopeIdentity(scope);
+      if (identities.has(identity)) continue;
+      identities.add(identity);
+      scopes.push(scope);
+      if (scopes.length === MAX_RECENT_MEMORY_SCOPES) break;
+    }
+    return scopes;
+  } catch {
+    return [];
+  }
+}
+
+export function rememberRecentMemoryScope(
+  storage: Pick<ScopeStorage, "getItem" | "setItem">,
+  dataScopeKey: string,
+  memoryStoreName: string,
+  value: Partial<MemoryScope>,
+): MemoryScope[] {
+  const current = readRecentMemoryScopes(
+    storage,
+    dataScopeKey,
+    memoryStoreName,
+  );
+  if (isAllWildcardMemoryScope(value)) return current;
+
+  const scope = normalizeRecentMemoryScope(value);
+  if (!scope) return current;
+
+  const identity = scopeIdentity(scope);
+  const next = [
+    scope,
+    ...current.filter((item) => scopeIdentity(item) !== identity),
+  ].slice(0, MAX_RECENT_MEMORY_SCOPES);
+
+  try {
+    storage.setItem(
+      getRecentMemoryScopeStorageKey(dataScopeKey, memoryStoreName),
+      JSON.stringify(next),
+    );
+  } catch {
+    // Scope history must never block memory navigation.
+  }
+  return next;
+}
+
+export function clearRecentMemoryScopes(
+  storage: Pick<ScopeStorage, "removeItem">,
+  dataScopeKey: string,
+  memoryStoreName: string,
+): void {
+  try {
+    storage.removeItem(
+      getRecentMemoryScopeStorageKey(dataScopeKey, memoryStoreName),
+    );
+  } catch {
+    // Scope history must never block memory navigation.
+  }
+}
+
+export function excludeRecentMemoryScopes(
+  knownScopes: readonly MemoryScope[],
+  recentScopes: readonly MemoryScope[],
+): MemoryScope[] {
+  const recentIdentities = new Set(
+    recentScopes
+      .map(normalizeRecentMemoryScope)
+      .filter((scope): scope is MemoryScope => scope !== null)
+      .map(scopeIdentity),
+  );
+
+  return knownScopes.filter((scope) => {
+    const normalized = normalizeRecentMemoryScope(scope);
+    return !normalized || !recentIdentities.has(scopeIdentity(normalized));
+  });
+}

package/dist/dashboard-runtime/dashboard/src/lib/memory.ts

@@ -53,6 +53,19 @@ export function formatScope(scope?: MemoryScope): string {
     .join(" / ");
 }
 
+/**
+ * Positional four-tuple label for the scope pickers. Unlike
+ * {@link formatScope}, an empty dimension keeps its slot as `—`, so rows line
+ * up column-wise in a dropdown and "no tenant" reads differently from "no
+ * agent". Shared by both pickers (ScopeCombobox and the ScopeBar) so their
+ * labels can't drift apart.
+ */
+export function scopeLabel(scope: MemoryScope): string {
+  return [scope.appId, scope.tenantId, scope.agentId, scope.runId]
+    .map((v) => v || "—")
+    .join(" / ");
+}
+
 /**
  * A set of dream tasks that share the same input scope.
  *

package/dist/dashboard-runtime/dashboard/src/lib/query-keys.ts

@@ -29,50 +29,46 @@ export const fileMemoryQueryKeys = {
       "list",
       pathPrefix,
     ] as const,
-  file: (
+  item: (
     dataScopeKey: string,
     memoryStoreName: string,
     scope: FileMemoryScope,
-    path: string,
+    address: string,
   ) =>
     [
       ...fileMemoryQueryKeys.root(dataScopeKey, memoryStoreName, scope),
-      "file",
-      path,
+      "item",
+      address,
     ] as const,
   versions: (
     dataScopeKey: string,
     memoryStoreName: string,
     scope: FileMemoryScope,
-    memoryId: string,
-    path?: string,
+    itemId: string,
   ) =>
     [
       ...fileMemoryQueryKeys.root(dataScopeKey, memoryStoreName, scope),
       "versions",
-      memoryId,
-      path,
+      itemId,
     ] as const,
   version: (
     dataScopeKey: string,
     memoryStoreName: string,
     scope: FileMemoryScope,
-    memoryId: string,
-    memoryVersionId: string,
-    versionSeq: number,
+    versionId: string,
   ) =>
     [
       ...fileMemoryQueryKeys.root(dataScopeKey, memoryStoreName, scope),
       "version",
-      memoryId,
-      memoryVersionId,
-      versionSeq,
+      versionId,
     ] as const,
 };
 
 export const queryKeys = {
   runtimeContext: RUNTIME_CONTEXT_QUERY_KEY,
   instances: (scope: string) => ["instances", scope] as const,
+  instanceConnectivity: (scope: string) =>
+    ["instance-connectivity", scope] as const,
   instance: (scope: string, name: string | null | undefined) =>
     ["instance", scope, name] as const,
   knowledgeBases: (scope: string) => ["knowledge-bases", scope] as const,

package/dist/dashboard-runtime/dashboard/src/lib/server/api-helpers.ts

@@ -44,6 +44,11 @@ const CODE_TO_HTTP_STATUS: Record<string, number> = {
   UNAUTHORIZED: 401,
   FORBIDDEN: 403,
   CONFLICT: 409,
+  PATH_EXISTS: 409,
+  LOCK_CONFLICT: 409,
+  QUOTA_EXCEEDED: 409,
+  READ_ONLY_STORE: 409,
+  PAYLOAD_TOO_LARGE: 413,
   QUOTA_EXHAUSTED: 429,
   FLOW_CONTROL: 429,
   INTERNAL_SERVER_ERROR: 500,

package/dist/dashboard-runtime/dashboard/src/lib/server/instance-connectivity.ts

@@ -0,0 +1,136 @@
+import type {
+  InstanceConnectivity,
+  InstanceConnectivityReason,
+} from "@/types/instance";
+
+const DEFAULT_TIMEOUT_MS = 3_000;
+const MAX_MESSAGE_LENGTH = 240;
+
+const DNS_CODES = new Set(["ENOTFOUND", "EAI_AGAIN", "EAI_FAIL"]);
+const CONNECTION_CODES = new Set([
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+]);
+const TLS_CODES = new Set([
+  "CERT_HAS_EXPIRED",
+  "CERT_NOT_YET_VALID",
+  "DEPTH_ZERO_SELF_SIGNED_CERT",
+  "ERR_TLS_CERT_ALTNAME_INVALID",
+  "SELF_SIGNED_CERT_IN_CHAIN",
+  "UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+  "UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+]);
+
+interface ProbeOptions {
+  fetchImpl?: typeof fetch;
+  timeoutMs?: number;
+  now?: () => number;
+}
+
+interface ErrorDetails {
+  reason: InstanceConnectivityReason;
+  message: string;
+}
+
+function safeMessage(value: unknown): string {
+  const message =
+    value instanceof Error && value.message.trim()
+      ? value.message
+      : "Network request failed";
+  return message.replace(/\s+/g, " ").slice(0, MAX_MESSAGE_LENGTH);
+}
+
+function errorDetails(error: unknown): ErrorDetails {
+  let current: unknown = error;
+  let deepestMessage = safeMessage(error);
+  const seen = new Set<unknown>();
+
+  while (current && typeof current === "object" && !seen.has(current)) {
+    seen.add(current);
+    const record = current as {
+      cause?: unknown;
+      code?: unknown;
+      message?: unknown;
+      name?: unknown;
+    };
+    if (typeof record.message === "string" && record.message.trim()) {
+      deepestMessage = record.message.replace(/\s+/g, " ");
+    }
+    if (record.name === "TimeoutError" || record.name === "AbortError") {
+      return { reason: "timeout", message: safeMessage(current) };
+    }
+    const code = typeof record.code === "string" ? record.code : "";
+    if (DNS_CODES.has(code)) {
+      return { reason: "dns", message: safeMessage(current) };
+    }
+    if (CONNECTION_CODES.has(code)) {
+      return { reason: "connection", message: safeMessage(current) };
+    }
+    if (TLS_CODES.has(code) || code.startsWith("ERR_TLS_")) {
+      return { reason: "tls", message: safeMessage(current) };
+    }
+    current = record.cause;
+  }
+
+  return {
+    reason: "network",
+    message: deepestMessage.replace(/\s+/g, " ").slice(0, MAX_MESSAGE_LENGTH),
+  };
+}
+
+export async function probeInstanceEndpoint(
+  endpoint: string,
+  options: ProbeOptions = {},
+): Promise<InstanceConnectivity> {
+  const now = options.now ?? Date.now;
+  const startedAt = now();
+  const checkedAt = () => new Date(now()).toISOString();
+
+  if (!endpoint.trim()) {
+    return { configured: false, reachable: null, checkedAt: checkedAt() };
+  }
+
+  let url: string;
+  try {
+    const parsed = new URL(endpoint);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new TypeError("unsupported protocol");
+    }
+    url = parsed.toString();
+  } catch {
+    return {
+      configured: true,
+      reachable: false,
+      checkedAt: checkedAt(),
+      latencyMs: Math.max(0, now() - startedAt),
+      reason: "network",
+      message: "Invalid endpoint URL",
+    };
+  }
+
+  try {
+    const response = await (options.fetchImpl ?? fetch)(url, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(options.timeoutMs ?? DEFAULT_TIMEOUT_MS),
+      redirect: "manual",
+      cache: "no-store",
+    });
+    return {
+      configured: true,
+      reachable: true,
+      checkedAt: checkedAt(),
+      latencyMs: Math.max(0, now() - startedAt),
+      httpStatus: response.status,
+    };
+  } catch (error) {
+    return {
+      configured: true,
+      reachable: false,
+      checkedAt: checkedAt(),
+      latencyMs: Math.max(0, now() - startedAt),
+      ...errorDetails(error),
+    };
+  }
+}

package/dist/dashboard-runtime/dashboard/src/lib/server/sdk-client.ts

@@ -57,6 +57,7 @@ export const TOKEN_SOURCE_COOKIE_NAME = "tablestore_token_source";
 const COOKIE_MAX_AGE_SECONDS = 60 * 60 * 24 * 30; // 30 days
 const RAW_TOKEN_SOURCE = "raw";
 const INSTANCE_TOKEN_SOURCE = "instance";
+const FORCE_ENV_VALUE = "1";
 
 const COOKIE_OPTIONS = {
   httpOnly: true,
@@ -272,6 +273,10 @@ function configFromEnv(): Record<string, string> | null {
   };
 }
 
+function shouldForceEnvCredentials(): boolean {
+  return process.env.TABLESTORE_DASHBOARD_FORCE_ENV === FORCE_ENV_VALUE;
+}
+
 function configFromToken(token: string): Record<string, string> {
   // decodeToken throws on malformed input; callers translate to 401.
   return decodeToken(token);
@@ -521,12 +526,13 @@ function cacheSet(key: string, value: ResolvedClients): void {
  */
 export function resolveClients(request: NextRequest): ResolvedClients {
   const token = request.cookies.get(SESSION_COOKIE_NAME)?.value;
+  const forceEnv = shouldForceEnvCredentials();
 
-  let fields: Record<string, string> | null = null;
+  let fields: Record<string, string> | null = forceEnv ? configFromEnv() : null;
   let source: CredentialSource = "env";
   let instanceName: string | null = null;
 
-  if (token) {
+  if (!forceEnv && token) {
     try {
       const tokenFields = configFromToken(token);
       if (shouldUseCookieCredentials(request, tokenFields)) {
@@ -542,7 +548,7 @@ export function resolveClients(request: NextRequest): ResolvedClients {
     }
   }
 
-  if (!fields) {
+  if (!forceEnv && !fields) {
     const fromInstance = configFromActiveInstance();
     if (fromInstance) {
       fields = fromInstance.fields;
@@ -591,6 +597,22 @@ export function inspectCredentials(request: NextRequest): {
   activeInstance: string | null;
   credentialFingerprint: string;
 } | null {
+  if (shouldForceEnvCredentials()) {
+    const fields = configFromEnv();
+    if (!fields) return null;
+    const region =
+      fields.region ||
+      inferRegionFromOtsEndpoint(fields.ots_endpoint) ||
+      DEFAULT_REGION;
+    return {
+      instanceName: fields.ots_instance_name,
+      region,
+      source: "env",
+      activeInstance: null,
+      credentialFingerprint: computeCredentialFingerprint(fields),
+    };
+  }
+
   const token = request.cookies.get(SESSION_COOKIE_NAME)?.value;
   if (token) {
     try {

package/dist/dashboard-runtime/dashboard/src/lib/subspace-history.ts

@@ -0,0 +1,151 @@
+export const MAX_RECENT_SUBSPACES = 10;
+
+const RECENT_STORAGE_KEY_PREFIX = "tsagent.kbSubspaces.v2";
+const ACTIVE_STORAGE_KEY_PREFIX = "tsagent.kbActiveSubspace.v2";
+
+type SubspaceStorage = Pick<Storage, "getItem" | "setItem" | "removeItem">;
+
+function normalizeSubspace(value: unknown): string | null {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim();
+  return normalized || null;
+}
+
+export function getRecentSubspaceStorageKey(
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): string {
+  return `${RECENT_STORAGE_KEY_PREFIX}:${JSON.stringify([
+    dataScopeKey,
+    knowledgeBaseName,
+  ])}`;
+}
+
+export function getActiveSubspaceStorageKey(
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): string {
+  return `${ACTIVE_STORAGE_KEY_PREFIX}:${JSON.stringify([
+    dataScopeKey,
+    knowledgeBaseName,
+  ])}`;
+}
+
+export function readRecentSubspaces(
+  storage: Pick<SubspaceStorage, "getItem">,
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): string[] {
+  try {
+    const raw = storage.getItem(
+      getRecentSubspaceStorageKey(dataScopeKey, knowledgeBaseName),
+    );
+    if (!raw) return [];
+    const parsed = JSON.parse(raw) as unknown;
+    if (!Array.isArray(parsed)) return [];
+
+    const seen = new Set<string>();
+    return parsed.reduce<string[]>((recent, item) => {
+      const subspace = normalizeSubspace(item);
+      if (
+        !subspace ||
+        seen.has(subspace) ||
+        recent.length >= MAX_RECENT_SUBSPACES
+      ) {
+        return recent;
+      }
+      seen.add(subspace);
+      recent.push(subspace);
+      return recent;
+    }, []);
+  } catch {
+    return [];
+  }
+}
+
+export function rememberRecentSubspace(
+  storage: Pick<SubspaceStorage, "getItem" | "setItem">,
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+  value: unknown,
+): string[] {
+  const subspace = normalizeSubspace(value);
+  const recent = readRecentSubspaces(storage, dataScopeKey, knowledgeBaseName);
+  if (!subspace) return recent;
+
+  const next = [subspace, ...recent.filter((item) => item !== subspace)].slice(
+    0,
+    MAX_RECENT_SUBSPACES,
+  );
+  try {
+    storage.setItem(
+      getRecentSubspaceStorageKey(dataScopeKey, knowledgeBaseName),
+      JSON.stringify(next),
+    );
+  } catch {
+    // Browser storage availability must not block navigation.
+  }
+  return next;
+}
+
+export function clearRecentSubspaces(
+  storage: Pick<SubspaceStorage, "removeItem">,
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): void {
+  try {
+    storage.removeItem(
+      getRecentSubspaceStorageKey(dataScopeKey, knowledgeBaseName),
+    );
+  } catch {
+    // Browser storage availability must not block navigation.
+  }
+}
+
+export function readActiveSubspace(
+  storage: Pick<SubspaceStorage, "getItem">,
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): string | null {
+  try {
+    return normalizeSubspace(
+      storage.getItem(
+        getActiveSubspaceStorageKey(dataScopeKey, knowledgeBaseName),
+      ),
+    );
+  } catch {
+    return null;
+  }
+}
+
+export function writeActiveSubspace(
+  storage: Pick<SubspaceStorage, "setItem">,
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+  value: unknown,
+): void {
+  const subspace = normalizeSubspace(value);
+  if (!subspace) return;
+  try {
+    storage.setItem(
+      getActiveSubspaceStorageKey(dataScopeKey, knowledgeBaseName),
+      subspace,
+    );
+  } catch {
+    // Browser storage availability must not block navigation.
+  }
+}
+
+export function clearActiveSubspace(
+  storage: Pick<SubspaceStorage, "removeItem">,
+  dataScopeKey: string,
+  knowledgeBaseName: string,
+): void {
+  try {
+    storage.removeItem(
+      getActiveSubspaceStorageKey(dataScopeKey, knowledgeBaseName),
+    );
+  } catch {
+    // Browser storage availability must not block navigation.
+  }
+}