@tablestore/tablestore-agent-cli 0.1.8 → 0.2.0

package/dist/dashboard-runtime/dashboard/src/app/api/v1/auth/status/route.ts

@@ -0,0 +1,53 @@
+import { type NextRequest } from "next/server";
+
+import { listInstances } from "@tablestore/tablestore-agent-shared";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+import {
+  ensureApiLogContext,
+  successResponse,
+  handleApiError,
+} from "@/lib/server/api-helpers";
+import { inspectCredentials } from "@/lib/server/sdk-client";
+
+/**
+ * GET /api/v1/auth/status
+ *
+ * Report whether credentials are configured for the current session.
+ * Response shape:
+ *   {
+ *     configured: boolean,
+ *     instanceName?: string,
+ *     region?: string,
+ *     hasAnyInstance: boolean,
+ *     activeInstance: string | null,
+ *   }
+ */
+export async function GET(request: NextRequest) {
+  ensureApiLogContext(request);
+  try {
+    const creds = inspectCredentials(request);
+    // Only named instances count for onboarding; the legacy [default] fallback
+    // does not trigger the full instance UX.
+    const hasAnyInstance = listInstances().some((r) => !r.is_default_fallback);
+
+    if (!creds) {
+      return successResponse({
+        configured: false,
+        hasAnyInstance,
+        activeInstance: null,
+      });
+    }
+    return successResponse({
+      configured: true,
+      instanceName: creds.instanceName,
+      region: creds.region,
+      hasAnyInstance,
+      activeInstance: creds.activeInstance,
+    });
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/auth/token/route.ts

@@ -0,0 +1,113 @@
+import { type NextRequest } from "next/server";
+
+import { CLIError, decodeToken } from "@tablestore/tablestore-agent-shared";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+import {
+  ensureApiLogContext,
+  errorResponse,
+  handleApiError,
+  successResponse,
+} from "@/lib/server/api-helpers";
+import {
+  SESSION_COOKIE_NAME,
+  clearActiveInstanceCookie,
+  clearTokenSourceCookie,
+  setRawTokenSourceCookie,
+} from "@/lib/server/sdk-client";
+
+/**
+ * Map decodeToken failures to a small set of user-facing reasons. We
+ * deliberately avoid leaking the raw `err.message` (which may include
+ * internal parsing details) to the client; instead we return a stable
+ * label that the dashboard can localize.
+ */
+function describeTokenError(err: unknown): string {
+  if (err instanceof CLIError && err.code === "INVALID_TOKEN") {
+    // CLIError messages from decodeToken are short, ASCII and safe to surface.
+    return err.message || "Token format is invalid";
+  }
+  return "Token format is invalid";
+}
+
+const COOKIE_MAX_AGE_SECONDS = 60 * 60 * 24 * 30; // 30 days
+
+/**
+ * POST /api/v1/auth/token
+ *
+ * Accept a portable `tablestore_agent_storage://...` token, validate its
+ * payload, and persist it in an http-only cookie for the current browser
+ * session. Response body matches `dashboard/src/services/auth.ts`:
+ *   { code, data: { imported: true }, message, requestId }
+ */
+export async function POST(request: NextRequest) {
+  ensureApiLogContext(request);
+  try {
+    let body: unknown;
+    try {
+      body = await request.json();
+    } catch {
+      return errorResponse("BAD_REQUEST", "Request body must be JSON", 400);
+    }
+
+    const token =
+      body !== null && typeof body === "object"
+        ? (body as { token?: unknown }).token
+        : undefined;
+
+    if (typeof token !== "string" || !token.trim()) {
+      return errorResponse("BAD_REQUEST", "Token is required", 400);
+    }
+
+    // Validate the token before storing it; throws on malformed payload.
+    try {
+      decodeToken(token);
+    } catch (err) {
+      return errorResponse("BAD_REQUEST", describeTokenError(err), 400);
+    }
+
+    const response = successResponse({ imported: true });
+    response.cookies.set(SESSION_COOKIE_NAME, token, {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      // sameSite=strict blocks the cookie on top-level cross-site
+      // navigations and image/script tag GETs, providing stronger CSRF
+      // defence than lax. Acceptable here because the dashboard is a
+      // first-party app with no expected cross-site entry points.
+      sameSite: "strict",
+      path: "/",
+      maxAge: COOKIE_MAX_AGE_SECONDS,
+    });
+    clearActiveInstanceCookie(response);
+    setRawTokenSourceCookie(response);
+    return response;
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+/**
+ * DELETE /api/v1/auth/token
+ *
+ * Clear the session cookie (sign-out).
+ */
+export async function DELETE(request: NextRequest) {
+  ensureApiLogContext(request);
+  try {
+    const response = successResponse({ cleared: true });
+    response.cookies.set(SESSION_COOKIE_NAME, "", {
+      httpOnly: true,
+      secure: process.env.NODE_ENV === "production",
+      sameSite: "strict",
+      path: "/",
+      maxAge: 0,
+    });
+    clearActiveInstanceCookie(response);
+    clearTokenSourceCookie(response);
+    return response;
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/instances/[name]/route.ts

@@ -0,0 +1,196 @@
+import { type NextRequest } from "next/server";
+
+import {
+  CLIError,
+  DEFAULT_INSTANCE_NAME,
+  encodeTokenV2,
+  getActiveInstanceName,
+  maskSecret,
+  readInstance,
+  removeInstance,
+  setActiveInstance,
+  writeInstance,
+} from "@tablestore/tablestore-agent-shared";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+import {
+  ensureApiLogContext,
+  errorResponse,
+  handleApiError,
+  successResponse,
+} from "@/lib/server/api-helpers";
+import {
+  ACTIVE_INSTANCE_COOKIE_NAME,
+  SESSION_COOKIE_NAME,
+  clearActiveInstanceCookie,
+  clearClientCache,
+  clearTokenSourceCookie,
+  setActiveInstanceCookie,
+  setInstanceTokenSourceCookie,
+} from "@/lib/server/sdk-client";
+import { updateInstanceSchema } from "@/schemas/instance";
+import type { InstanceDetail } from "@/types/instance";
+
+interface RouteContext {
+  params: Promise<{ name: string }>;
+}
+
+/**
+ * GET /api/v1/instances/[name]
+ *
+ * Return a masked detail view. Raw AK/SK are never returned.
+ */
+export async function GET(_request: NextRequest, context: RouteContext) {
+  ensureApiLogContext(_request);
+  try {
+    const { name } = await context.params;
+    const detail = readInstance(name);
+    if (!detail) {
+      throw new CLIError("NOT_FOUND", `Instance "${name}" does not exist.`);
+    }
+    const activeInstance = getActiveInstanceName();
+    const body: InstanceDetail = {
+      name,
+      active: activeInstance === name,
+      otsInstanceName: detail.ots_instance_name || undefined,
+      otsEndpoint: detail.ots_endpoint || undefined,
+      ossEndpoint: detail.oss_endpoint || undefined,
+      ossBucketName: detail.oss_bucket_name || undefined,
+      region: detail.region || undefined,
+      hasOss: Boolean(detail.oss_endpoint && detail.oss_bucket_name),
+      isDefaultFallback: name === DEFAULT_INSTANCE_NAME || undefined,
+      accessKeyIdMasked: detail.access_key_id
+        ? maskSecret(detail.access_key_id)
+        : undefined,
+      accessKeySecretMasked: detail.access_key_secret
+        ? maskSecret(detail.access_key_secret)
+        : undefined,
+      memoryDefaults: {
+        storeName: detail.memory_store_name || undefined,
+        appId: detail.memory_app_id || undefined,
+        tenantId: detail.memory_tenant_id || undefined,
+        agentId: detail.memory_agent_id || undefined,
+        runId: detail.memory_run_id || undefined,
+      },
+    };
+    return successResponse(body);
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+/**
+ * PUT /api/v1/instances/[name]
+ *
+ * Partial update. Empty string fields are stripped so callers can omit
+ * unchanged values without wiping them on disk.
+ */
+export async function PUT(request: NextRequest, context: RouteContext) {
+  ensureApiLogContext(request);
+  try {
+    const { name } = await context.params;
+    const raw = await request.json().catch(() => null);
+    const parsed = updateInstanceSchema.safeParse(raw);
+    if (!parsed.success) {
+      return errorResponse(
+        "VALIDATION_ERROR",
+        parsed.error.issues
+          .map((issue) => `${issue.path.join(".")}: ${issue.message}`)
+          .join("; "),
+        400,
+      );
+    }
+    const existing = readInstance(name);
+    if (!existing) {
+      throw new CLIError("NOT_FOUND", `Instance "${name}" does not exist.`);
+    }
+
+    const patch: Record<string, string> = {};
+    const d = parsed.data;
+    if (d.accessKeyId) patch.access_key_id = d.accessKeyId;
+    if (d.accessKeySecret) patch.access_key_secret = d.accessKeySecret;
+    if (d.otsEndpoint) patch.ots_endpoint = d.otsEndpoint;
+    if (d.otsInstanceName) patch.ots_instance_name = d.otsInstanceName;
+    if (d.ossEndpoint !== undefined) patch.oss_endpoint = d.ossEndpoint;
+    if (d.ossBucketName !== undefined) patch.oss_bucket_name = d.ossBucketName;
+    if (d.region !== undefined) patch.region = d.region;
+
+    writeInstance(name, patch);
+
+    const activeInstance = getActiveInstanceName();
+    if (activeInstance === name) {
+      clearClientCache();
+      const updated = readInstance(name)!;
+      const ots = updated.managed_ots;
+      const oss = updated.managed_oss;
+      const token = encodeTokenV2({
+        access_key_id: updated.access_key_id,
+        access_key_secret: updated.access_key_secret,
+        ots_endpoint: updated.ots_endpoint || ots.ots_endpoint,
+        ots_instance_name:
+          updated.ots_instance_name || ots.ots_instance_name,
+        oss_endpoint: updated.oss_endpoint || oss.oss_endpoint,
+        oss_bucket_name: updated.oss_bucket_name || oss.oss_bucket_name,
+        region: updated.region || ots.region || oss.region,
+      });
+      const response = successResponse({ name });
+      response.cookies.set({
+        name: SESSION_COOKIE_NAME,
+        value: token,
+        httpOnly: true,
+        sameSite: "strict",
+        secure: process.env.NODE_ENV === "production",
+        path: "/",
+      });
+      setActiveInstanceCookie(response, name);
+      setInstanceTokenSourceCookie(response);
+      return response;
+    }
+
+    return successResponse({ name });
+  } catch (error) {
+    return handleApiError(error);
+  }
+}
+
+/**
+ * DELETE /api/v1/instances/[name]
+ *
+ * Remove the named instance. If it was active, the active pointer is cleared
+ * and the new active instance (possibly null) is returned for the client to
+ * re-sync session state.
+ */
+export async function DELETE(_request: NextRequest, context: RouteContext) {
+  ensureApiLogContext(_request);
+  try {
+    const { name } = await context.params;
+    const wasActive = getActiveInstanceName() === name;
+    removeInstance(name);
+    const requestActiveInstance =
+      _request.cookies.get(ACTIVE_INSTANCE_COOKIE_NAME)?.value;
+    let shouldClearActiveCookie = wasActive;
+    if (requestActiveInstance) {
+      try {
+        shouldClearActiveCookie =
+          shouldClearActiveCookie ||
+          decodeURIComponent(requestActiveInstance) === name;
+      } catch {
+        shouldClearActiveCookie = true;
+      }
+    }
+    if (wasActive) {
+      setActiveInstance(null);
+      clearClientCache();
+    }
+    const response = successResponse({ activeInstance: getActiveInstanceName() });
+    if (shouldClearActiveCookie) {
+      clearActiveInstanceCookie(response);
+      clearTokenSourceCookie(response);
+    }
+    return response;
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/instances/[name]/token/route.ts

@@ -0,0 +1,80 @@
+import { type NextRequest } from "next/server";
+
+import {
+  CLIError,
+  encodeTokenV2,
+  getActiveInstanceName,
+  loadConfig,
+  readInstance,
+  setActiveInstance,
+} from "@tablestore/tablestore-agent-shared";
+
+import {
+  ensureApiLogContext,
+  handleApiError,
+  successResponse,
+} from "@/lib/server/api-helpers";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+interface RouteContext {
+  params: Promise<{ name: string }>;
+}
+
+/**
+ * GET /api/v1/instances/[name]/token
+ *
+ * Produce a portable v2 token for the named instance. The token embeds the
+ * 7 token fields (ak, sk, ots endpoint/instance, oss endpoint/bucket, region)
+ * and can be consumed by `configure import <token>` or by POST /instances
+ * with `{ token }`.
+ */
+export async function GET(_request: NextRequest, context: RouteContext) {
+  ensureApiLogContext(_request);
+  try {
+    const { name } = await context.params;
+    const detail = readInstance(name);
+    if (!detail) {
+      throw new CLIError("NOT_FOUND", `Instance "${name}" does not exist.`);
+    }
+    // Project the requested instance through loadConfig so any managed_oss /
+    // managed_ots subsection collapses into the flat oss_endpoint /
+    // oss_bucket_name fields the v2 token carries. We temporarily flip the
+    // active instance pointer when the caller is not already pointed at this
+    // name, then restore it; this keeps the token export stateless from the
+    // caller's perspective even when the instance is dormant.
+    const previousActive = getActiveInstanceName();
+    let effectiveOssEndpoint = detail.oss_endpoint;
+    let effectiveOssBucket = detail.oss_bucket_name;
+    let effectiveRegion = detail.region;
+    if (previousActive !== name) {
+      try {
+        setActiveInstance(name);
+        const effective = loadConfig();
+        effectiveOssEndpoint = effective.oss_endpoint || effectiveOssEndpoint;
+        effectiveOssBucket = effective.oss_bucket_name || effectiveOssBucket;
+        effectiveRegion = effective.region || effectiveRegion;
+      } finally {
+        setActiveInstance(previousActive);
+      }
+    } else {
+      const effective = loadConfig();
+      effectiveOssEndpoint = effective.oss_endpoint || effectiveOssEndpoint;
+      effectiveOssBucket = effective.oss_bucket_name || effectiveOssBucket;
+      effectiveRegion = effective.region || effectiveRegion;
+    }
+    const token = encodeTokenV2({
+      access_key_id: detail.access_key_id,
+      access_key_secret: detail.access_key_secret,
+      ots_endpoint: detail.ots_endpoint,
+      ots_instance_name: detail.ots_instance_name,
+      oss_endpoint: effectiveOssEndpoint,
+      oss_bucket_name: effectiveOssBucket,
+      region: effectiveRegion,
+    });
+    return successResponse({ token, name });
+  } catch (error) {
+    return handleApiError(error);
+  }
+}

package/dist/dashboard-runtime/dashboard/src/app/api/v1/instances/[name]/use/route.ts

@@ -0,0 +1,91 @@
+import { type NextRequest } from "next/server";
+
+import {
+  CLIError,
+  encodeTokenV2,
+  readInstance,
+  setActiveInstance,
+} from "@tablestore/tablestore-agent-shared";
+
+export const runtime = "nodejs";
+export const dynamic = "force-dynamic";
+
+import {
+  ensureApiLogContext,
+  handleApiError,
+  successResponse,
+} from "@/lib/server/api-helpers";
+import {
+  SESSION_COOKIE_NAME,
+  clearClientCache,
+  setActiveInstanceCookie,
+  setInstanceTokenSourceCookie,
+} from "@/lib/server/sdk-client";
+
+interface RouteContext {
+  params: Promise<{ name: string }>;
+}
+
+/**
+ * POST /api/v1/instances/[name]/use
+ *
+ * Switch the active instance. Re-signs the tablestore_token cookie so the
+ * SDK client layer immediately resolves to the new credentials.
+ */
+export async function POST(_request: NextRequest, context: RouteContext) {
+  ensureApiLogContext(_request);
+  try {
+    const { name } = await context.params;
+    const detail = readInstance(name);
+    if (!detail) {
+      throw new CLIError("NOT_FOUND", `Instance "${name}" does not exist.`);
+    }
+    setActiveInstance(name);
+
+    // Drop every cached SDK client. The new active instance's OTS / OSS
+    // coordinates differ, but the cache fingerprint may not change when only
+    // the active-instance flag flips on disk — evicting unconditionally is
+    // the only correct behaviour at a tenant switch boundary, and avoids
+    // the AccessDeniedError that surfaces when a stale NodeAgentStorageClient
+    // (bound to the previous tenant's OSS bucket) is reused for the next
+    // upload.
+    clearClientCache();
+
+    // Project the per-instance managed_ots / managed_oss tables onto the
+    // flat ots_*/oss_* fields carried by the session cookie. The legacy
+    // top-level [managed_*] tables are gone (and migrated by the shared
+    // loader), so the only authoritative source for the active instance's
+    // auto-provisioned coordinates is the nested subsection on `detail`.
+    // Doing this here means the SDK never has to re-read the active
+    // instance from disk — the cookie alone is enough to construct a
+    // correctly-bound NodeAgentStorageClient on the next request.
+    const ots = detail.managed_ots;
+    const oss = detail.managed_oss;
+    const response = successResponse({ activeInstance: name });
+    const token = encodeTokenV2({
+      access_key_id: detail.access_key_id,
+      access_key_secret: detail.access_key_secret,
+      ots_endpoint: detail.ots_endpoint || ots.ots_endpoint,
+      ots_instance_name: detail.ots_instance_name || ots.ots_instance_name,
+      oss_endpoint: detail.oss_endpoint || oss.oss_endpoint,
+      oss_bucket_name: detail.oss_bucket_name || oss.oss_bucket_name,
+      region:
+        detail.region || ots.region || oss.region,
+    });
+    response.cookies.set({
+      name: SESSION_COOKIE_NAME,
+      value: token,
+      httpOnly: true,
+      // Match the strict policy used in /api/v1/auth/token so every
+      // session cookie write across the dashboard stays consistent.
+      sameSite: "strict",
+      secure: process.env.NODE_ENV === "production",
+      path: "/",
+    });
+    setActiveInstanceCookie(response, name);
+    setInstanceTokenSourceCookie(response);
+    return response;
+  } catch (error) {
+    return handleApiError(error);
+  }
+}