warpmetal 0.8.13 → 0.9.0

package/src/customer-auth.js

@@ -0,0 +1,329 @@
+import { spawn } from "node:child_process";
+
+import { CliError } from "./errors.js";
+import { USER_AGENT } from "./version.js";
+
+export const CUSTOMER_CLI_CLIENT_ID = "warpmetal-customer-cli";
+export const DEFAULT_IDENTITY_ORIGIN = "https://identity.warpmetal.com";
+export const DEFAULT_ACCOUNT_ORIGIN = "https://warpmetal.com";
+
+const DEVICE_GRANT = "urn:ietf:params:oauth:grant-type:device_code";
+const SAFE_ERROR = /^[a-z][a-z0-9_]{0,63}$/;
+
+export function validateOrigin(value, label) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new CliError(`Invalid ${label}: ${value}`, { exitCode: 2 });
+  }
+  const local = ["localhost", "127.0.0.1", "::1"].includes(url.hostname);
+  if (url.protocol !== "https:" && !(local && url.protocol === "http:")) {
+    throw new CliError(
+      `${label} must use HTTPS (HTTP is allowed for localhost).`,
+      { exitCode: 2 },
+    );
+  }
+  if (
+    url.username ||
+    url.password ||
+    url.search ||
+    url.hash ||
+    (url.pathname !== "" && url.pathname !== "/")
+  ) {
+    throw new CliError(
+      `${label} must be an origin without credentials, path, query, or fragment data.`,
+      { exitCode: 2 },
+    );
+  }
+  return url.origin;
+}
+
+function responseError(data, status) {
+  const candidate =
+    typeof data?.error === "string"
+      ? data.error
+      : data?.error?.code || data?.detail?.code;
+  const code = SAFE_ERROR.test(candidate || "") ? candidate : "unavailable";
+  return new CliError(`Account authorization failed: ${code} (HTTP ${status}).`, {
+    exitCode: code === "access_denied" || code === "denied" ? 4 : 3,
+    code,
+  });
+}
+
+function parseJson(text) {
+  try {
+    return text ? JSON.parse(text) : {};
+  } catch {
+    throw new CliError("The account service returned an invalid response.", {
+      exitCode: 3,
+      code: "invalid_response",
+    });
+  }
+}
+
+function combinedSignal(signal, timeoutMs) {
+  const timeout = AbortSignal.timeout(timeoutMs);
+  return signal ? AbortSignal.any([signal, timeout]) : timeout;
+}
+
+function delay(milliseconds, signal) {
+  return new Promise((resolveDelay, rejectDelay) => {
+    let cancel;
+    const timer = setTimeout(() => {
+      if (cancel) signal.removeEventListener("abort", cancel);
+      resolveDelay();
+    }, milliseconds);
+    if (!signal) return;
+    cancel = () => {
+      clearTimeout(timer);
+      rejectDelay(
+        new CliError("Account authorization was cancelled.", {
+          exitCode: 130,
+          code: "cancelled",
+        }),
+      );
+    };
+    if (signal.aborted) cancel();
+    else signal.addEventListener("abort", cancel, { once: true });
+  });
+}
+
+function exactScopes(value) {
+  if (typeof value !== "string") return null;
+  const scopes = value.split(/\s+/).filter(Boolean);
+  if (
+    scopes.length === 0 ||
+    new Set(scopes).size !== scopes.length ||
+    scopes.some((scope) => !["cli:read", "cli:write"].includes(scope))
+  ) {
+    return null;
+  }
+  return scopes;
+}
+
+function validateToken(data, requestedScopes) {
+  const scopes = exactScopes(data?.scope);
+  if (
+    typeof data?.access_token !== "string" ||
+    data.access_token.length === 0 ||
+    typeof data?.refresh_token !== "string" ||
+    !data.refresh_token.startsWith("wmclr_") ||
+    data?.token_type?.toLowerCase() !== "bearer" ||
+    !Number.isSafeInteger(data?.expires_in) ||
+    data.expires_in <= 0 ||
+    !scopes ||
+    scopes.some((scope) => !requestedScopes.includes(scope)) ||
+    !requestedScopes.every((scope) => scopes.includes(scope))
+  ) {
+    throw new CliError("The account service returned an invalid token response.", {
+      exitCode: 3,
+      code: "invalid_response",
+    });
+  }
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    accessExpiresAt: new Date(Date.now() + data.expires_in * 1_000).toISOString(),
+    scopes,
+  };
+}
+
+export class CustomerAuthClient {
+  constructor({ identityOrigin, accountOrigin, fetchImpl = globalThis.fetch, timeoutMs = 30_000 } = {}) {
+    if (typeof fetchImpl !== "function") {
+      throw new CliError("This Node.js runtime does not provide fetch().", {
+        exitCode: 2,
+      });
+    }
+    this.identityOrigin = validateOrigin(
+      identityOrigin || DEFAULT_IDENTITY_ORIGIN,
+      "WarpMetal Identity URL",
+    );
+    this.accountOrigin = validateOrigin(
+      accountOrigin || DEFAULT_ACCOUNT_ORIGIN,
+      "WarpMetal account URL",
+    );
+    this.fetchImpl = fetchImpl;
+    this.timeoutMs = timeoutMs;
+  }
+
+  async #form(path, fields, { signal } = {}) {
+    const url = new URL(path, `${this.identityOrigin}/`);
+    let response;
+    try {
+      response = await this.fetchImpl(url, {
+        method: "POST",
+        redirect: "manual",
+        headers: {
+          Accept: "application/json",
+          "Content-Type": "application/x-www-form-urlencoded",
+          "User-Agent": USER_AGENT,
+        },
+        body: new URLSearchParams(fields).toString(),
+        signal: combinedSignal(signal, this.timeoutMs),
+      });
+    } catch (error) {
+      if (signal?.aborted) {
+        throw new CliError("Account authorization was cancelled.", {
+          exitCode: 130,
+          code: "cancelled",
+        });
+      }
+      throw new CliError(`Could not reach ${url.origin}.`, {
+        exitCode: 3,
+        code: "unavailable",
+      });
+    }
+    if (response.status >= 300 && response.status < 400) {
+      throw new CliError("Account authorization refused an HTTP redirect.", {
+        exitCode: 3,
+        code: "redirect_refused",
+      });
+    }
+    const data = parseJson(await response.text());
+    return { ok: response.ok, status: response.status, data };
+  }
+
+  async begin(scopes, { signal } = {}) {
+    const result = await this.#form(
+      "/oauth/device_authorization",
+      { client_id: CUSTOMER_CLI_CLIENT_ID, scope: scopes.join(" ") },
+      { signal },
+    );
+    if (!result.ok) throw responseError(result.data, result.status);
+    const data = result.data;
+    if (
+      typeof data?.device_code !== "string" ||
+      data.device_code.length === 0 ||
+      typeof data?.user_code !== "string" ||
+      data.user_code.length === 0 ||
+      !Number.isSafeInteger(data?.expires_in) ||
+      data.expires_in <= 0 ||
+      !Number.isSafeInteger(data?.interval) ||
+      data.interval <= 0
+    ) {
+      throw new CliError("The account service returned an invalid device authorization.", {
+        exitCode: 3,
+        code: "invalid_response",
+      });
+    }
+    let verification;
+    let complete;
+    try {
+      verification = new URL(data.verification_uri);
+      complete = new URL(data.verification_uri_complete);
+    } catch {
+      throw new CliError("The account service returned an invalid verification URL.", {
+        exitCode: 3,
+        code: "invalid_response",
+      });
+    }
+    if (
+      verification.origin !== this.accountOrigin ||
+      complete.origin !== this.accountOrigin ||
+      verification.username ||
+      verification.password ||
+      complete.username ||
+      complete.password ||
+      verification.hash ||
+      complete.hash ||
+      verification.pathname !== "/account/cli" ||
+      complete.pathname !== "/account/cli" ||
+      verification.search ||
+      complete.searchParams.size !== 1 ||
+      complete.searchParams.get("user_code") !== data.user_code
+    ) {
+      throw new CliError("The account service returned an untrusted verification URL.", {
+        exitCode: 3,
+        code: "invalid_response",
+      });
+    }
+    return {
+      deviceCode: data.device_code,
+      userCode: data.user_code,
+      verificationUri: verification.toString(),
+      verificationUriComplete: complete.toString(),
+      expiresIn: data.expires_in,
+      interval: data.interval,
+      scopes,
+    };
+  }
+
+  async poll(device, { signal } = {}) {
+    const deadline = Date.now() + device.expiresIn * 1_000;
+    let interval = device.interval * 1_000;
+    while (Date.now() < deadline) {
+      await delay(Math.min(interval, Math.max(1, deadline - Date.now())), signal);
+      if (Date.now() >= deadline) break;
+      const result = await this.#form(
+        "/oauth/token",
+        {
+          grant_type: DEVICE_GRANT,
+          device_code: device.deviceCode,
+          client_id: CUSTOMER_CLI_CLIENT_ID,
+        },
+        { signal },
+      );
+      if (result.ok) return validateToken(result.data, device.scopes);
+      const code =
+        typeof result.data?.error === "string"
+          ? result.data.error
+          : result.data?.error?.code || result.data?.detail?.code;
+      if (code === "authorization_pending") continue;
+      if (code === "slow_down") {
+        interval += 5_000;
+        continue;
+      }
+      throw responseError(result.data, result.status);
+    }
+    throw new CliError("Account authorization failed: expired_token.", {
+      exitCode: 3,
+      code: "expired_token",
+    });
+  }
+
+  async refresh(refreshToken, scopes, { signal } = {}) {
+    const result = await this.#form(
+      "/oauth/token",
+      {
+        grant_type: "refresh_token",
+        refresh_token: refreshToken,
+        client_id: CUSTOMER_CLI_CLIENT_ID,
+      },
+      { signal },
+    );
+    if (!result.ok) throw responseError(result.data, result.status);
+    return validateToken(result.data, scopes);
+  }
+
+  async revoke(refreshToken, { signal } = {}) {
+    const result = await this.#form(
+      "/oauth/revoke",
+      { token: refreshToken, client_id: CUSTOMER_CLI_CLIENT_ID },
+      { signal },
+    );
+    if (!result.ok) throw responseError(result.data, result.status);
+  }
+}
+
+export function openVerificationPage(url, { platform = process.platform, spawnImpl = spawn } = {}) {
+  const command =
+    platform === "darwin"
+      ? ["open", [url]]
+      : platform === "win32"
+        ? ["rundll32.exe", ["url.dll,FileProtocolHandler", url]]
+        : ["xdg-open", [url]];
+  try {
+    const child = spawnImpl(command[0], command[1], {
+      detached: true,
+      stdio: "ignore",
+      shell: false,
+    });
+    child.on?.("error", () => {});
+    child.unref?.();
+    return true;
+  } catch {
+    return false;
+  }
+}

package/src/models.js

@@ -0,0 +1,85 @@
+import { CliError } from "./errors.js";
+
+export const MODEL_AUTH_MODES = new Set(["api_key", "chatgpt_subscription"]);
+const CATALOG_STATES = new Set(["fresh", "stale", "suppressed"]);
+
+function invalidCatalog() {
+  throw new CliError("WarpMetal returned an invalid public model catalog.", {
+    exitCode: 3,
+  });
+}
+
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function entry(value) {
+  if (
+    !object(value) ||
+    typeof value.entryId !== "string" ||
+    typeof value.providerId !== "string" ||
+    typeof value.modelId !== "string" ||
+    !Array.isArray(value.authModes) ||
+    value.authModes.some((mode) => !MODEL_AUTH_MODES.has(mode))
+  ) {
+    invalidCatalog();
+  }
+  return value;
+}
+
+/**
+ * Validates the stable public fields needed by the CLI without projecting away
+ * snapshot provenance or additive metadata published by the catalog service.
+ */
+export function validateModelCatalog(value) {
+  if (
+    !object(value) ||
+    value.schemaVersion !== 1 ||
+    !CATALOG_STATES.has(value.state) ||
+    !Array.isArray(value.entries) ||
+    !object(value.recommended) ||
+    !Array.isArray(value.recommended.managers) ||
+    !Array.isArray(value.recommended.workers) ||
+    value.recommended.managers.some((id) => typeof id !== "string") ||
+    value.recommended.workers.some((id) => typeof id !== "string")
+  ) {
+    invalidCatalog();
+  }
+  value.entries.forEach(entry);
+  return value;
+}
+
+export function filterModelCatalog(catalog, { provider, authMode } = {}) {
+  const published = validateModelCatalog(catalog);
+  const entries = published.entries.filter(
+    (item) =>
+      (provider === undefined || item.providerId === provider) &&
+      (authMode === undefined || item.authModes.includes(authMode)),
+  );
+  const retainedIds = new Set(entries.map((item) => item.entryId));
+  return {
+    ...published,
+    entries,
+    recommended: {
+      ...published.recommended,
+      managers: published.recommended.managers.filter((id) => retainedIds.has(id)),
+      workers: published.recommended.workers.filter((id) => retainedIds.has(id)),
+    },
+  };
+}
+
+export function modelCatalogHuman(catalog) {
+  const header = [
+    `Model catalog: ${catalog.state}`,
+    `Snapshot: ${catalog.snapshotId ?? "unavailable"}`,
+    `Source: ${catalog.sourceAttribution ?? catalog.source?.id ?? "unavailable"}`,
+  ];
+  if (catalog.entries.length === 0) {
+    return [...header, "No models match the published catalog and selected filters."].join("\n");
+  }
+  const entries = catalog.entries.map(
+    (item) =>
+      `${item.entryId} (${item.authModes.join(", ")})`,
+  );
+  return [...header, ...entries].join("\n");
+}

package/src/runtime.js

@@ -15,10 +15,82 @@ const SANDBOX_FIELDS = new Set([
   "lifetime",
   "expiresInSeconds",
 ]);
-const RUNTIME_FIELDS = new Set(["sandboxes", "setup"]);
+const RUNTIME_FIELDS = new Set(["sandboxes", "setup", "teams"]);
 const SETUP_FIELDS = new Set(["version", "sandboxProfiles"]);
 const SANDBOX_PROFILE_FIELDS = new Set(["sandboxName", "profileId"]);
 
+function record(value, allowed, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new CliError(`${label} must be a JSON object.`, { exitCode: 2 });
+  }
+  exactFields(value, new Set(allowed), label);
+  return value;
+}
+
+function invalidTeam(message) {
+  throw new CliError(message, { exitCode: 2 });
+}
+
+// Same structural team-v1 boundary as checkout. Model/provider qualification
+// remains server-owned; parsing an intent never enables runtime execution.
+export function validateTeamIntent(value, sandboxes) {
+  record(value, ["version", "teams"], "teams");
+  if (value.version !== 1 || !Array.isArray(value.teams) || value.teams.length !== 1) {
+    invalidTeam("teams version 1 requires exactly one team.");
+  }
+  const team = record(value.teams[0], ["name", "members", "links", "startPolicy"], "A team");
+  if (typeof team.name !== "string" || !team.name || team.name.length > 64 ||
+      team.name.trim() !== team.name || /[\u0000-\u001f\u007f]/.test(team.name)) {
+    invalidTeam("Team names must be 1-64 characters without controls or outer whitespace.");
+  }
+  if (team.startPolicy !== "manual") invalidTeam("Team startPolicy must be manual.");
+  if (!Array.isArray(team.members) || team.members.length < 2 || team.members.length > 8) {
+    invalidTeam("A team requires 2-8 members.");
+  }
+  const declared = new Set(sandboxes.map((sandbox) => sandbox.name));
+  const names = new Set();
+  const members = team.members.map((raw) => {
+    const member = record(raw, ["sandboxName", "role", "providerId", "modelId", "authMode"], "A team member");
+    if (typeof member.sandboxName !== "string" || !declared.has(member.sandboxName) || names.has(member.sandboxName)) {
+      invalidTeam("Each team member must reference a distinct declared sandbox.");
+    }
+    names.add(member.sandboxName);
+    if (!["manager", "worker", "reviewer"].includes(member.role)) invalidTeam("Invalid team member role.");
+    if (typeof member.providerId !== "string" || !/^[a-z0-9](?:[a-z0-9._-]{0,62}[a-z0-9])?$/.test(member.providerId)) {
+      invalidTeam("Team providerId must be an exact lowercase provider identifier.");
+    }
+    if (member.modelId != null && (typeof member.modelId !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/.test(member.modelId))) {
+      invalidTeam("Team modelId must be a bare model identifier.");
+    }
+    if (member.authMode != null && (!["api_key", "chatgpt_subscription"].includes(member.authMode) ||
+        (member.authMode === "chatgpt_subscription" && member.providerId !== "openai"))) {
+      invalidTeam("Team authMode must be api_key or, for OpenAI, chatgpt_subscription.");
+    }
+    return { sandboxName: member.sandboxName, role: member.role, providerId: member.providerId,
+      ...(member.modelId == null ? {} : { modelId: member.modelId }),
+      ...(member.authMode == null ? {} : { authMode: member.authMode }) };
+  });
+  const managers = members.filter((member) => member.role === "manager");
+  if (managers.length !== 1) invalidTeam("A team requires exactly one manager.");
+  const rawLinks = team.links === undefined ? [] : team.links;
+  if (!Array.isArray(rawLinks) || rawLinks.length > 56) invalidTeam("Team links must have at most 56 entries.");
+  const triples = new Set();
+  const links = rawLinks.map((raw) => {
+    const link = record(raw, ["from", "to", "capability"], "A team link");
+    if (!names.has(link.from) || !names.has(link.to) || link.from === link.to ||
+        !["task.delegate", "message.send"].includes(link.capability) ||
+        (link.capability === "task.delegate" && link.from !== managers[0].sandboxName)) {
+      invalidTeam("Team links require distinct members; only the manager may delegate tasks.");
+    }
+    const triple = `${link.from}>${link.to}:${link.capability}`;
+    if (triples.has(triple)) invalidTeam("Duplicate team links are not allowed.");
+    triples.add(triple);
+    return { from: link.from, to: link.to, capability: link.capability };
+  });
+  return { version: 1, teams: [{ name: team.name, members,
+    ...(links.length ? { links } : {}), startPolicy: "manual" }] };
+}
+
 function exactFields(value, allowed, label) {
   const unknown = Object.keys(value).find((field) => !allowed.has(field));
   if (unknown)
@@ -118,7 +190,8 @@ export async function readSandboxFile(path) {
   }
   exactFields(document, RUNTIME_FIELDS, "The sandbox JSON file");
   const sandboxes = validateSandboxBatch(document.sandboxes);
-  if (document.setup === undefined) return sandboxes;
+  const teams = document.teams === undefined ? undefined : validateTeamIntent(document.teams, sandboxes);
+  if (document.setup === undefined) return teams ? { sandboxes, teams } : sandboxes;
   const setup = document.setup;
   if (!setup || typeof setup !== "object" || Array.isArray(setup)) {
     throw new CliError("setup must be a JSON object.", { exitCode: 2 });
@@ -171,7 +244,7 @@ export async function readSandboxFile(path) {
     selectedNames.add(input.sandboxName);
     return { sandboxName: input.sandboxName, profileId: input.profileId };
   });
-  return { sandboxes, setup: { version: 1, sandboxProfiles } };
+  return { sandboxes, setup: { version: 1, sandboxProfiles }, ...(teams ? { teams } : {}) };
 }
 
 export function containsTemporary(sandboxes) {

package/src/state.js

@@ -232,19 +232,35 @@ export class StateStore {
     return result;
   }
 
-  async savePreparedOrder(response, checkoutBody, identityId) {
+  async savePreparedOrder(response, checkoutBody, identityId, account = null) {
     const { task, ownerToken } = response;
-    if (!task?.id || !task?.serverId || !ownerToken) {
+    if (!task?.id || !task?.serverId || (account ? ownerToken !== undefined : !ownerToken)) {
       throw new CliError("WarpMetal returned an incomplete prepared order.");
     }
+    if (account && (!account.principalId || !account.accountOrigin || !account.identityOrigin)) {
+      throw new CliError("The prepared order is missing its account binding.");
+    }
+    const authority = account ? {
+      ownershipMode: "account",
+      accountPrincipalId: account.principalId,
+      accountOrigin: account.accountOrigin,
+      identityOrigin: account.identityOrigin,
+    } : { ownerToken };
     await this.update((state) => {
+      const previous = state.orders[task.id];
+      const previousServer = state.servers[task.serverId];
+      if ([previous, previousServer].some((record) => record && (account
+        ? record.ownerToken || (record.accountPrincipalId && record.accountPrincipalId !== account.principalId)
+        : record.ownershipMode === "account"))) {
+        throw new CliError("The prepared order conflicts with an existing local ownership binding.");
+      }
       state.orders[task.id] = {
         taskId: task.id,
         serverId: task.serverId,
         planId: task.planId,
         checkoutPath: task.checkoutPath,
         checkoutBody,
-        ownerToken,
+        ...authority,
         identityId,
         createdAt: new Date().toISOString(),
       };
@@ -252,7 +268,7 @@ export class StateStore {
         ...(state.servers[task.serverId] || {}),
         serverId: task.serverId,
         taskId: task.id,
-        ownerToken,
+        ...authority,
         identityId,
       };
       if (identityId && state.identities[identityId]) {