@abelxiaoxing/cadence 2.0.13 → 2.0.14

package/src/service-http-client.ts

@@ -1,3 +1,7 @@
+import type {
+  WorkbenchCommand,
+  WorkbenchRead,
+} from "./service/contracts/workbench.ts";
 import type { ServiceTransport } from "./service-client.ts";
 import {
   type CancelCommand,
@@ -63,6 +67,8 @@ export class HttpServiceTransport implements ServiceTransport {
   constructor(
     private readonly options: {
       origin: string;
+      /** Authenticated same-origin project routing; never an arbitrary URL. */
+      project?: string;
       build?: ClientBuild;
       fetch?: typeof fetch;
       /** Optional total bound for finite replies only, never streaming export. */
@@ -78,12 +84,26 @@ export class HttpServiceTransport implements ServiceTransport {
         !/^http:\/\/(?:127\.0\.0\.1|\[::1\]):[1-9][0-9]*$/.test(options.origin))
     )
       throw new ContractError("invalid");
+    if (
+      options.project !== undefined &&
+      !/^[a-f0-9]{64}$/.test(options.project)
+    )
+      throw new ContractError("invalid");
     this.origin = options.origin;
     if (options.build) options.build = decodeClientBuild(options.build);
     // Native browser fetch requires its Window receiver. Node/injected arrow
     // fetchers tolerate the wrong `this`, so HTTP-only fixtures miss this bug.
     this.fetcher = options.fetch ?? globalThis.fetch.bind(globalThis);
   }
+  workbenchRead(
+    request: WorkbenchRead,
+    signal?: AbortSignal,
+  ): Promise<unknown> {
+    return this.request("workbenchRead", request, signal);
+  }
+  workbenchCommand(request: WorkbenchCommand): Promise<unknown> {
+    return this.request("workbenchCommand", request);
+  }
   private headers(write: boolean): Record<string, string> {
     const headers: Record<string, string> = { "Cache-Control": "no-store" };
     if (this.options.build)
@@ -109,20 +129,23 @@ export class HttpServiceTransport implements ServiceTransport {
       write = wire.method === "POST";
     // No automatic session/preflight refresh, changed command ID, mutation retry,
     // credential query or redirect follow after an uncertain HTTP outcome.
-    const response = await this.fetcher(`${this.origin}${wire.path}`, {
-      method: wire.method,
-      headers: this.headers(write),
-      credentials: "same-origin",
-      redirect: "error",
-      signal:
-        this.options.requestTimeoutMs === undefined
-          ? signal
-          : AbortSignal.any([
-              ...(signal ? [signal] : []),
-              AbortSignal.timeout(this.options.requestTimeoutMs),
-            ]),
-      ...(write ? { body: wire.body } : {}),
-    });
+    const response = await this.fetcher(
+      `${this.origin}${this.options.project ? `/projects/${this.options.project}` : ""}${wire.path}`,
+      {
+        method: wire.method,
+        headers: this.headers(write),
+        credentials: "same-origin",
+        redirect: "error",
+        signal:
+          this.options.requestTimeoutMs === undefined
+            ? signal
+            : AbortSignal.any([
+                ...(signal ? [signal] : []),
+                AbortSignal.timeout(this.options.requestTimeoutMs),
+              ]),
+        ...(write ? { body: wire.body } : {}),
+      },
+    );
     // Keep a known allocation even if its original response body is lost or
     // malformed. Without a validated CSRF challenge detach may remain blocked;
     // never silently forget that slot and acquire 16 replacement sessions.
@@ -273,14 +296,17 @@ export class HttpServiceTransport implements ServiceTransport {
   ): AsyncGenerator<unknown> {
     const request = decodeExportRequest(input),
       wire = wireRequest("export", request);
-    const response = await this.fetcher(`${this.origin}${wire.path}`, {
-      method: wire.method,
-      headers: this.headers(wire.method === "POST"),
-      ...(wire.body === undefined ? {} : { body: wire.body }),
-      credentials: "same-origin",
-      redirect: "error",
-      signal,
-    });
+    const response = await this.fetcher(
+      `${this.origin}${this.options.project ? `/projects/${this.options.project}` : ""}${wire.path}`,
+      {
+        method: wire.method,
+        headers: this.headers(wire.method === "POST"),
+        ...(wire.body === undefined ? {} : { body: wire.body }),
+        credentials: "same-origin",
+        redirect: "error",
+        signal,
+      },
+    );
     if (!response.ok || !response.body) {
       await response.body?.cancel();
       throw new ContractError("unavailable");
@@ -336,7 +362,7 @@ export class HttpServiceTransport implements ServiceTransport {
     if (!this.attachment || !this.options.socket)
       throw new ContractError("unavailable");
     const socket = this.options.socket(
-      `${this.origin.replace(/^http/, "ws")}${WS_PATH}?attachment=${this.attachment}`,
+      `${this.origin.replace(/^http/, "ws")}${this.options.project ? `/projects/${this.options.project}` : ""}${WS_PATH}?attachment=${this.attachment}`,
     );
     let active = false,
       closed = false,
@@ -401,7 +427,7 @@ export class HttpServiceTransport implements ServiceTransport {
     return stop;
   }
 }
-async function boundedText(
+export async function boundedText(
   response: Response,
   maximum: number,
 ): Promise<string> {

package/src/service-wire.ts

@@ -1,4 +1,9 @@
 import { closed, oneOf } from "./service/contracts/core.ts";
+import {
+  decodeWorkbenchCommand,
+  decodeWorkbenchRead,
+  decodeWorkbenchResult,
+} from "./service/contracts/workbench.ts";
 /** Portable finite HTTP/WS route owner. Common DTO semantics stay in service-contract. */
 import {
   ContractError,
@@ -44,6 +49,8 @@ import {
 
 export const HTTP_ROUTES = {
   session: "/api/v1/session",
+  workbenchRead: "/api/v1/workbench/read",
+  workbenchCommand: "/api/v1/workbench/command",
   current: "/api/v1/current",
   currentChanges: "/api/v1/current-changes",
   activeRuns: "/api/v1/active-runs",
@@ -102,7 +109,9 @@ export function httpOutputLimit(
     operation === "activeRuns" ||
     operation === "workspace" ||
     operation === "models" ||
-    operation === "chooseModel"
+    operation === "chooseModel" ||
+    operation === "workbenchRead" ||
+    operation === "workbenchCommand"
   )
     return LIMITS.pageBytes;
   if (operation === "graph") {
@@ -117,12 +126,21 @@ export function httpOutputLimit(
   return LIMITS.controlBytes;
 }
 export function mutation(operation: HttpOperation): boolean {
-  return ["preflight", "command", "cancel", "detach", "chooseModel"].includes(
-    operation,
-  );
+  return [
+    "preflight",
+    "command",
+    "cancel",
+    "detach",
+    "chooseModel",
+    "workbenchCommand",
+  ].includes(operation);
 }
 export function decodeHttpInput(operation: HttpOperation, value: unknown) {
   switch (operation) {
+    case "workbenchRead":
+      return decodeWorkbenchRead(value);
+    case "workbenchCommand":
+      return decodeWorkbenchCommand(value);
     case "session":
     case "models":
     case "activeRuns":
@@ -179,6 +197,9 @@ export function decodeHttpOutput(
   if ((pageReaders as readonly string[]).includes(operation))
     return decodeReply(value, decodeHistoryReadResult);
   switch (operation) {
+    case "workbenchRead":
+    case "workbenchCommand":
+      return decodeReply(value, decodeWorkbenchResult);
     case "current":
       return decodeReply(value, decodeCurrentView);
     case "currentChanges":
@@ -225,6 +246,7 @@ export function decodeHttpOutput(
 export function readonlyBody(operation: HttpOperation): boolean {
   const operations: readonly HttpOperation[] = [
     ...pageReaders,
+    "workbenchRead",
     "current",
     "currentChanges",
     "checkObligations",

package/src/task-store.ts

@@ -251,7 +251,7 @@ export function savedRecordIdentity(record: TaskRecord): string {
   return contentIdentity(recordText(record));
 }
 /** Resolve ambient aliases, including a missing tail, without creating anything. */
-function canonicalAmbientRoot(path: string): string {
+export function canonicalAmbientRoot(path: string): string {
   const full = resolve(path);
   try {
     return realpathSync(full);
@@ -304,20 +304,21 @@ export function privateWorkspace(
     canonicalAmbientRoot(requested),
   );
 }
-export const LANDING_WORKSPACE = "cadence";
-/** A directory that contains the private state home (the home directory and
- * its ancestors) can never be a workspace; use ~/cadence instead of refusing.
- * Observation only: the caller decides whether the landing may be created. */
+/** A project must be explicit and outside private state. Never choose, create or
+ * reconstruct a default workspace. The workbench itself has no project cwd. */
 export function effectiveWorkspace(
   requested: string,
   stateHome?: string,
-  home = homedir(),
+  _home?: string,
 ): { workspace: string; redirected: boolean } {
-  if (privateWorkspace(requested, stateHome))
-    throw new Error("Private state cannot be a workspace");
-  if (!stateHomeInside(resolveWorkspace(requested).root, stateHome))
-    return { workspace: requested, redirected: false };
-  return { workspace: join(home, LANDING_WORKSPACE), redirected: true };
+  if (
+    privateWorkspace(requested, stateHome) ||
+    stateHomeInside(resolveWorkspace(requested).root, stateHome)
+  )
+    throw new Error(
+      "Choose a project outside Cadence private state; no default workspace was created",
+    );
+  return { workspace: requested, redirected: false };
 }
 export interface CheckoutLock {
   schema: "cadence-assistant-lock/1";