openpond 0.0.38 → 0.0.40

package/dist/chunks/{chunk-QRM7XMAO.js → chunk-ZTE6A2VE.js}

@@ -1,11 +1,8 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
-  DEFAULT_OPENPOND_API_BASE_URL,
   DEFAULT_OPENPOND_CHAT_MODEL,
-  DEFAULT_OPENPOND_WEB_BASE_URL,
   ProviderCatalogSchema,
   SandboxAppActionRegistrySchema,
-  checkOpenPondApiHealth,
   createRepo,
   getAppEnvironment,
   getOpenPondAccount,
@@ -15,7 +12,12 @@ import {
   saveConfig,
   saveProfileApiKey,
   setActiveProfile
-} from "./chunk-LZZM3IHS.js";
+} from "./chunk-2SF6HLT7.js";
+import {
+  DEFAULT_OPENPOND_API_BASE_URL,
+  DEFAULT_OPENPOND_WEB_BASE_URL,
+  withVercelProtectionBypass
+} from "./chunk-KHNHUA2H.js";
 
 // ../../packages/runtime/dist/chat.js
 import { randomUUID } from "node:crypto";
@@ -78,6 +80,9 @@ function normalizeOpChatApiBaseUrl(value) {
     return null;
   try {
     const url = new URL(normalized);
+    if (url.hostname.toLowerCase() === "api-new.staging-api.openpond.ai") {
+      url.hostname = "staging-api.openpond.ai";
+    }
     const segments = url.pathname.split("/").filter(Boolean);
     const opChatIndex = segments.findIndex((segment) => segment.toLowerCase() === "opchat");
     if (opChatIndex >= 0) {
@@ -111,11 +116,12 @@ function deriveEnvironment(fallback) {
 }
 
 // ../../packages/runtime/dist/selectors.js
-function accountToken(account) {
+function accountToken(account, env = process.env) {
   const candidates = [
     account?.apiKey,
     account?.session?.token,
-    account?.token
+    account?.token,
+    env.OPENPOND_API_KEY
   ];
   for (const value of candidates) {
     const trimmed = typeof value === "string" ? value.trim() : "";
@@ -406,7 +412,7 @@ function errorMessage(error) {
 }
 
 // ../../packages/runtime/dist/chat.js
-var PROVIDER_CATALOG_FETCH_TIMEOUT_MS = 2500;
+var PROVIDER_CATALOG_FETCH_TIMEOUT_MS = 15e3;
 async function loadOpenPondProviderCatalog() {
   const context = await loadOpenPondAccountContext();
   if (!context.token) {
@@ -451,13 +457,16 @@ async function* streamOpenPondHostedChatTurn(input) {
     tools: input.tools,
     toolChoice: input.toolChoice,
     requestId: input.requestId,
+    reasoningEffort: input.reasoningEffort,
+    maxTokens: input.maxTokens,
     signal: input.signal
   });
 }
 async function listOpChatProviderCatalog(options) {
-  const response = await fetch(opChatEndpointUrl(options.apiBaseUrl, "provider-catalog"), {
+  const requestUrl = opChatEndpointUrl(options.apiBaseUrl, "provider-catalog");
+  const response = await fetch(requestUrl, {
     method: "GET",
-    headers: opChatHeaders(options.token, "application/json"),
+    headers: opChatHeaders(requestUrl, options.token, "application/json"),
     signal: options.signal
   });
   if (!response.ok) {
@@ -466,56 +475,61 @@ async function listOpChatProviderCatalog(options) {
   return ProviderCatalogSchema.parse(await response.json());
 }
 async function* streamOpChatChatCompletion(options) {
-  const response = await fetch(opChatEndpointUrl(options.apiBaseUrl, "chat/completions"), {
+  const requestUrl = opChatEndpointUrl(options.apiBaseUrl, "chat/completions");
+  const response = await fetch(requestUrl, {
     method: "POST",
-    headers: opChatHeaders(options.token, "text/event-stream", options.requestId),
-    body: JSON.stringify(buildOpChatBody(options)),
+    headers: opChatHeaders(requestUrl, options.token, "application/json", options.requestId),
+    // Hosted turns are published only after the provider finishes. Requesting
+    // the complete response also preserves whitespace that some upstream
+    // token streams omit at chunk boundaries.
+    body: JSON.stringify(buildOpChatBody(options, false)),
     signal: options.signal
   });
-  if (!response.ok || !response.body) {
-    throw new Error(`OpenPond OpChat stream failed: ${response.status} ${await readOpChatError(response)}`);
+  if (!response.ok) {
+    throw new Error(`OpenPond OpChat request failed: ${response.status} ${await readOpChatError(response)}`);
   }
-  let reasoningText = "";
-  let hasToolCalls = false;
-  let pendingFinish = null;
-  let latestRaw = null;
-  for await (const raw of parseOpChatSse(response.body, options.signal)) {
-    latestRaw = raw;
-    if (raw && typeof raw === "object" && "error" in raw) {
-      throw new Error(`OpenPond OpChat stream failed: ${errorMessageFromPayload(raw)}`);
-    }
-    const usage = parseUsage(raw);
-    if (usage)
-      yield { type: "usage", usage, raw };
-    for (const delta of streamDeltasFromChunk(raw)) {
-      if (delta.type === "reasoning_delta")
-        reasoningText += delta.text;
-      if (delta.type === "tool_call_delta")
-        hasToolCalls = true;
-      if (delta.type === "finish")
-        pendingFinish = delta;
-      else
-        yield delta;
-    }
+  const raw = await response.json();
+  if (raw && typeof raw === "object" && "error" in raw) {
+    throw new Error(`OpenPond OpChat request failed: ${errorMessageFromPayload(raw)}`);
+  }
+  const record = raw && typeof raw === "object" ? raw : {};
+  const choices = Array.isArray(record.choices) ? record.choices : [];
+  const choice = choices[0] && typeof choices[0] === "object" ? choices[0] : {};
+  const message = choice.message && typeof choice.message === "object" ? choice.message : {};
+  const reasoningText = streamTextValue(message.reasoning_content);
+  const content = streamTextValue(message.content);
+  const toolCalls = parseToolCalls(message.tool_calls);
+  const usage = parseUsage(raw);
+  if (reasoningText)
+    yield { type: "reasoning_delta", text: reasoningText, raw };
+  if (content)
+    yield { type: "text_delta", text: content, raw };
+  if (toolCalls.length > 0) {
+    yield { type: "tool_call_delta", toolCalls, raw };
   }
-  if (hasToolCalls && reasoningText) {
+  if (toolCalls.length > 0 && reasoningText) {
     yield {
       type: "continuation",
       continuation: {
         kind: "chat_completions_reasoning",
         reasoningContent: reasoningText
       },
-      raw: latestRaw
+      raw
     };
   }
-  if (pendingFinish)
-    yield pendingFinish;
+  if (usage)
+    yield { type: "usage", usage, raw };
+  yield {
+    type: "finish",
+    finishReason: stringValue(choice.finish_reason),
+    raw
+  };
 }
-function buildOpChatBody(options) {
+function buildOpChatBody(options, stream) {
   const body = {
     model: options.model,
     messages: options.messages.map(opChatMessage),
-    stream: true
+    stream
   };
   if (options.tools) {
     body.tools = options.tools;
@@ -523,8 +537,23 @@ function buildOpChatBody(options) {
   if (options.toolChoice !== void 0) {
     body.tool_choice = options.toolChoice;
   }
+  if (typeof options.maxTokens === "number") {
+    body.max_tokens = options.maxTokens;
+  }
+  Object.assign(body, opChatReasoningFields(options.reasoningEffort));
   return body;
 }
+function opChatReasoningFields(effort) {
+  if (!effort)
+    return {};
+  if (effort === "low") {
+    return { thinking: { type: "disabled" } };
+  }
+  return {
+    thinking: { type: "enabled" },
+    reasoning_effort: effort === "xhigh" ? "max" : "high"
+  };
+}
 function opChatMessage(message) {
   const { continuation, ...projected } = message;
   if (message.role === "assistant" && continuation?.kind === "chat_completions_reasoning") {
@@ -541,7 +570,7 @@ function opChatEndpointUrl(apiBaseUrl, path) {
     throw new Error("OpenPond OpChat API base URL is required.");
   return `${normalized}/${path}`;
 }
-function opChatHeaders(token, accept, requestId) {
+function opChatHeaders(requestUrl, token, accept, requestId) {
   const trimmed = token.trim();
   if (!trimmed)
     throw new Error("OpenPond API key is required for OpChat.");
@@ -551,7 +580,7 @@ function opChatHeaders(token, accept, requestId) {
   headers.set("Accept", accept);
   headers.set("x-openpond-client", "openpond-app");
   headers.set("x-openpond-request-id", requestId || randomUUID());
-  return headers;
+  return withVercelProtectionBypass(requestUrl, headers);
 }
 async function readOpChatError(response) {
   const text = await response.text().catch(() => "");
@@ -578,72 +607,6 @@ function errorMessageFromPayload(payload) {
   }
   return [stringValue(record.error), stringValue(record.message)].filter(Boolean).join(": ") || JSON.stringify(payload);
 }
-async function* parseOpChatSse(stream, signal) {
-  const reader = stream.getReader();
-  const decoder = new TextDecoder();
-  let buffer = "";
-  const abortError = () => signal?.reason instanceof Error ? signal.reason : new Error("openpond_opchat_aborted");
-  try {
-    while (true) {
-      if (signal?.aborted)
-        throw abortError();
-      const result = await reader.read();
-      if (result.done)
-        break;
-      buffer += decoder.decode(result.value, { stream: true });
-      const blocks = buffer.split(/\r?\n\r?\n/);
-      buffer = blocks.pop() ?? "";
-      for (const block of blocks) {
-        for (const payload of parseSseBlock(block))
-          yield payload;
-      }
-    }
-  } finally {
-    reader.releaseLock();
-  }
-  buffer += decoder.decode();
-  if (buffer.trim()) {
-    for (const payload of parseSseBlock(buffer))
-      yield payload;
-  }
-}
-function parseSseBlock(block) {
-  const data = block.split(/\r?\n/).filter((line) => line.startsWith("data:")).map((line) => line.slice(5).trim()).join("\n").trim();
-  if (!data || data === "[DONE]")
-    return [];
-  return [JSON.parse(data)];
-}
-function streamDeltasFromChunk(raw) {
-  if (!raw || typeof raw !== "object")
-    return [];
-  const record = raw;
-  const choices = Array.isArray(record.choices) ? record.choices : [];
-  const deltas = [];
-  for (const choice of choices) {
-    if (!choice || typeof choice !== "object")
-      continue;
-    const choiceRecord = choice;
-    const delta = choiceRecord.delta && typeof choiceRecord.delta === "object" ? choiceRecord.delta : {};
-    for (const key of ["content", "reasoning_content"]) {
-      const value = stringValue(delta[key]);
-      if (!value)
-        continue;
-      deltas.push({
-        type: key === "content" ? "text_delta" : "reasoning_delta",
-        text: value,
-        raw
-      });
-    }
-    const toolCalls = parseToolCalls(delta.tool_calls);
-    if (toolCalls.length > 0) {
-      deltas.push({ type: "tool_call_delta", toolCalls, raw });
-    }
-    const finishReason = stringValue(choiceRecord.finish_reason);
-    if (finishReason)
-      deltas.push({ type: "finish", finishReason, raw });
-  }
-  return deltas;
-}
 function parseToolCalls(value) {
   return Array.isArray(value) ? value.filter((item) => Boolean(item) && typeof item === "object") : [];
 }
@@ -658,6 +621,9 @@ function parseUsage(raw) {
 function stringValue(value) {
   return typeof value === "string" && value.trim() ? value : null;
 }
+function streamTextValue(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
 
 // ../../packages/runtime/dist/version.js
 import { readFileSync as readFileSync2 } from "node:fs";
@@ -837,71 +803,76 @@ async function loadAccountProfileLookups(context) {
     const key = profileKey(account.handle, account.baseUrl);
     const token = accountToken(account);
     if (!token) {
-      return [key, { response: null, authFailed: false }];
+      return [
+        key,
+        { response: null, authFailed: false, error: null }
+      ];
     }
     try {
       return [
         key,
         {
           response: await getOpenPondAccount(resolvePublicApiBaseUrl(account, context.config), token),
-          authFailed: false
+          authFailed: false,
+          error: null
+        }
+      ];
+    } catch (error) {
+      return [
+        key,
+        {
+          response: null,
+          authFailed: true,
+          error: errorMessage(error)
         }
       ];
-    } catch {
-      return [key, { response: null, authFailed: true }];
     }
   }));
   return Object.fromEntries(entries);
 }
+async function loadOpenPondAccountStateForContext(context) {
+  const accountProfiles = await loadAccountProfileLookups(context);
+  const activeLookup = context.account ? accountProfiles[profileKey(context.account.handle, context.account.baseUrl)] ?? null : null;
+  const accountResponse = activeLookup?.response ?? null;
+  const authError = context.token && activeLookup?.authFailed ? activeLookup.error || "OpenPond account authentication failed." : null;
+  return {
+    account: toAccountState({
+      ...context,
+      accountResponse,
+      accountProfiles,
+      authFailed: Boolean(authError),
+      error: authError
+    })
+  };
+}
+async function loadOpenPondAccountState() {
+  return loadOpenPondAccountStateForContext(await loadOpenPondAccountContext());
+}
 async function loadOpenPondApps(options = {}) {
   const context = await loadOpenPondAccountContext();
+  const accountPromise = loadOpenPondAccountStateForContext(context);
   if (!context.token) {
-    const accountProfiles2 = await loadAccountProfileLookups(context);
     return {
-      account: toAccountState({ ...context, accountProfiles: accountProfiles2 }),
+      ...await accountPromise,
       apps: [],
       error: "No OpenPond API key or session token is configured."
     };
   }
-  const [healthResult, accountResult, appsResult, accountProfilesResult] = await Promise.allSettled([
-    checkOpenPondApiHealth(context.apiBaseUrl, context.token),
-    getOpenPondAccount(context.apiBaseUrl, context.token),
+  const [accountResult, appsResult] = await Promise.allSettled([
+    accountPromise,
     listApps(context.apiBaseUrl, context.token, {
       handle: context.account?.handle,
       limit: options.limit ?? 20,
       offset: options.offset ?? 0,
       includeScheduled: options.includeScheduled ?? true
-    }),
-    loadAccountProfileLookups(context)
+    })
   ]);
-  const health = healthResult.status === "fulfilled" ? healthResult.value : null;
-  const accountResponse = accountResult.status === "fulfilled" ? accountResult.value : null;
-  const accountProfiles = accountProfilesResult.status === "fulfilled" ? accountProfilesResult.value : {};
-  if (accountResult.status === "fulfilled" && context.account) {
-    accountProfiles[profileKey(context.account.handle, context.account.baseUrl)] = {
-      response: accountResult.value,
-      authFailed: false
-    };
-  }
-  const appsSucceeded = appsResult.status === "fulfilled";
-  const accountSucceeded = accountResult.status === "fulfilled";
-  const anyAuthenticatedCallSucceeded = appsSucceeded || accountSucceeded || health?.authenticated === true;
-  const allAuthenticatedCallsFailed = !appsSucceeded && !accountSucceeded && health?.authenticated !== true;
-  const authError = health?.authenticated === false && !anyAuthenticatedCallSucceeded ? health.error || "OpenPond account authentication failed." : allAuthenticatedCallsFailed ? appsResult.status === "rejected" ? errorMessage(appsResult.reason) : accountResult.status === "rejected" ? errorMessage(accountResult.reason) : null : null;
-  const profileError = accountResult.status === "rejected" && anyAuthenticatedCallSucceeded ? `Profile unavailable: ${errorMessage(accountResult.reason)}` : null;
-  const appsError = appsResult.status === "rejected" ? errorMessage(appsResult.reason) : null;
-  const effectiveHealth = health && anyAuthenticatedCallSucceeded ? { ...health, authenticated: true, error: void 0 } : health;
+  if (accountResult.status === "rejected")
+    throw accountResult.reason;
   return {
-    account: toAccountState({
-      ...context,
-      accountResponse,
-      accountProfiles,
-      health: effectiveHealth,
-      authFailed: Boolean(authError),
-      error: authError ?? profileError
-    }),
+    account: accountResult.value.account,
     apps: appsResult.status === "fulfilled" ? appsResult.value.map(normalizeApp).filter((value) => Boolean(value)) : [],
-    error: appsError
+    error: appsResult.status === "rejected" ? errorMessage(appsResult.reason) : null
   };
 }
 async function createOpenPondRepoApp(input) {
@@ -939,20 +910,6 @@ async function deriveHandleForApiKey(input, apiBaseUrl) {
       return fromProfile;
   } catch {
   }
-  try {
-    const apps = await listApps(apiBaseUrl, input.apiKey);
-    const counts = /* @__PURE__ */ new Map();
-    for (const app of apps) {
-      const handle2 = normalizeDerivedHandle(app.handle);
-      if (!handle2)
-        continue;
-      counts.set(handle2, (counts.get(handle2) ?? 0) + 1);
-    }
-    const [handle] = Array.from(counts.entries()).sort((left, right) => right[1] - left[1])[0] ?? [];
-    if (handle)
-      return handle;
-  } catch {
-  }
   return fallbackHandleForApiKey(input.apiKey);
 }
 async function saveOpenPondAccount(input) {
@@ -972,8 +929,41 @@ async function saveOpenPondAccount(input) {
   return loadOpenPondAccountContext(handle, baseUrl);
 }
 
+// ../../packages/runtime/dist/remove-account.js
+function findAccountIndex(accounts, handle, baseUrl) {
+  const normalizedBaseUrl = normalizeBaseUrl(baseUrl);
+  const exactIndex = accounts.findIndex((account) => handleEquals(account.handle, handle) && baseUrlEquals(account.baseUrl, normalizedBaseUrl));
+  if (exactIndex !== -1)
+    return exactIndex;
+  const matchingIndexes = accounts.map((account, index) => ({ account, index })).filter(({ account }) => handleEquals(account.handle, handle));
+  if (matchingIndexes.length === 1)
+    return matchingIndexes[0].index;
+  if (matchingIndexes.length > 1) {
+    throw new Error(`Multiple OpenPond accounts match ${handle}; select one with its base URL.`);
+  }
+  return -1;
+}
+async function removeOpenPondAccount(input) {
+  const handle = input.handle.trim();
+  if (!handle)
+    throw new Error("OpenPond account handle is required.");
+  const config = await loadGlobalConfig();
+  const accounts = (config.accounts ?? []).map((account2) => ({ ...account2 }));
+  const index = findAccountIndex(accounts, handle, input.baseUrl);
+  if (index === -1)
+    throw new Error(`OpenPond account not found: ${handle}`);
+  const account = accounts[index];
+  const activeProfile = normalizeActiveProfile(config.activeProfile);
+  if (activeProfile && accountMatchesSelector(account, activeProfile)) {
+    throw new Error("Switch to another OpenPond account before removing the active account.");
+  }
+  accounts.splice(index, 1);
+  await saveConfig({ ...config, accounts });
+  return loadOpenPondAccountContext();
+}
+
 // ../../packages/runtime/dist/update-account-config.js
-function findAccountIndex(accounts, handle, currentBaseUrl) {
+function findAccountIndex2(accounts, handle, currentBaseUrl) {
   const normalizedCurrentBaseUrl = normalizeBaseUrl(currentBaseUrl);
   const exactIndex = accounts.findIndex((account) => handleEquals(account.handle, handle) && baseUrlEquals(account.baseUrl, normalizedCurrentBaseUrl));
   if (exactIndex !== -1)
@@ -1003,7 +993,7 @@ async function updateOpenPondAccountConfig(input) {
     throw new Error("OpenPond account handle is required.");
   const config = await loadGlobalConfig();
   const accounts = (config.accounts ?? []).map((account) => ({ ...account }));
-  const index = findAccountIndex(accounts, handle, input.currentBaseUrl);
+  const index = findAccountIndex2(accounts, handle, input.currentBaseUrl);
   if (index === -1)
     throw new Error(`OpenPond account not found: ${handle}`);
   const previousAccount = accounts[index];
@@ -1082,11 +1072,13 @@ function nextLineEnd(value) {
 export {
   loadOpenPondAccountContext,
   switchOpenPondAccount,
+  loadOpenPondAccountState,
   loadOpenPondApps,
   createOpenPondRepoApp,
   loadOpenPondProviderCatalog,
   streamOpenPondHostedChatTurn,
   saveOpenPondAccount,
+  removeOpenPondAccount,
   updateOpenPondAccountConfig,
   getOpenPondAppEnvironment,
   getBundledRuntimeVersion,

package/dist/chunks/{cli-7BKDWFNU.js → cli-ZIY4LAYZ.js}

@@ -1,15 +1,19 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   resolveWebLaunchMessages,
+  runOpenPondAppServerCli,
   runOpenPondServerCli
-} from "./chunk-YTJL6XPU.js";
-import "./chunk-HS2AGRDV.js";
-import "./chunk-QRM7XMAO.js";
-import "./chunk-LZZM3IHS.js";
-import "./chunk-XEJ7XXUQ.js";
+} from "./chunk-75ZLFVFZ.js";
+import "./chunk-VCVQLECH.js";
+import "./chunk-ZTE6A2VE.js";
+import "./chunk-CZG4XKVF.js";
+import "./chunk-2SF6HLT7.js";
+import "./chunk-M2NXTLH2.js";
 import "./chunk-WYDVQOBL.js";
+import "./chunk-KHNHUA2H.js";
 import "./chunk-UACZUFIA.js";
 export {
   resolveWebLaunchMessages,
+  runOpenPondAppServerCli,
   runOpenPondServerCli
 };

package/dist/chunks/{core-commands-YN4RMWA3.js → core-commands-D66KZEHU.js}

@@ -16,11 +16,13 @@ import {
   runTemplateUpdate,
   runToolList,
   runToolRun
-} from "./chunk-AHPQTEIJ.js";
-import "./chunk-275WCETC.js";
-import "./chunk-GDZYDLEL.js";
-import "./chunk-XCATKTK3.js";
-import "./chunk-ZI4GDAUB.js";
+} from "./chunk-MCBAI5M5.js";
+import "./chunk-FCVVOMIP.js";
+import "./chunk-KHNHUA2H.js";
+import "./chunk-KSOI7GFA.js";
+import "./chunk-SMNFI2FU.js";
+import "./chunk-QHUJ2XVJ.js";
+import "./chunk-DBHSOTYZ.js";
 import "./chunk-KSRWKXRB.js";
 import "./chunk-MUMPWI4O.js";
 import "./chunk-UACZUFIA.js";

package/dist/chunks/{harness-BHQRMXJR.js → desktop-test-FDA6MV77.js}

@@ -1,12 +1,14 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   runProcessCommand
-} from "./chunk-275WCETC.js";
+} from "./chunk-FCVVOMIP.js";
+import "./chunk-KHNHUA2H.js";
 import {
   CliUsageError
-} from "./chunk-GDZYDLEL.js";
-import "./chunk-XCATKTK3.js";
-import "./chunk-ZI4GDAUB.js";
+} from "./chunk-KSOI7GFA.js";
+import "./chunk-SMNFI2FU.js";
+import "./chunk-QHUJ2XVJ.js";
+import "./chunk-DBHSOTYZ.js";
 import "./chunk-KSRWKXRB.js";
 import {
   optionString,
@@ -14,13 +16,13 @@ import {
 } from "./chunk-MUMPWI4O.js";
 import "./chunk-UACZUFIA.js";
 
-// src/cli/harness.ts
+// src/cli/desktop-test.ts
 import path from "node:path";
 import { access } from "node:fs/promises";
 import { constants } from "node:fs";
 import { createRequire } from "node:module";
 var DESKTOP_HARNESS_SCRIPT = path.join("scripts", "desktop-harness.ts");
-async function runHarnessCommand(options, rest) {
+async function runDesktopTestCommand(options, rest) {
   const invocation = await buildDesktopHarnessInvocation({ options, rest });
   const result = await runProcessCommand(invocation.command, invocation.args, {
     cwd: invocation.cwd,
@@ -34,14 +36,13 @@ async function runHarnessCommand(options, rest) {
 async function buildDesktopHarnessInvocation(input) {
   const options = input.options;
   const rest = input.rest;
-  const surface = rest[0];
-  const action = rest[1];
-  if (surface !== "desktop" || action !== "run" && action !== "attach") {
+  const action = rest[0];
+  if (action !== "run" && action !== "attach") {
     throw new CliUsageError(desktopHarnessCliUsage());
   }
-  const scenarios = rest.slice(2);
+  const scenarios = rest.slice(1);
   if (scenarios.length === 0) {
-    throw new CliUsageError("usage: openpond harness desktop run <scenario...> [options]");
+    throw new CliUsageError("usage: openpond desktop-test run <scenario...> [options]");
   }
   const startCwd = optionString(options, "cwd") || input.cwd || process.cwd();
   const repoRoot = await resolveDesktopHarnessRepoRoot(startCwd);
@@ -118,8 +119,8 @@ async function fileExists(filePath) {
 }
 function desktopHarnessCliUsage() {
   return [
-    "usage: openpond harness desktop run <scenario...> [options]",
-    "       openpond harness desktop attach <scenario...> [options]",
+    "usage: openpond desktop-test run <scenario...> [options]",
+    "       openpond desktop-test attach <scenario...> [options]",
     "",
     "Options include --isolated, --attach, --packaged, --none, --app <path>,",
     "--server <url>, --token <token>, --token-file <path>, --devtools-port <port>, --artifacts-dir <path>,",
@@ -139,5 +140,5 @@ var HarnessCommandFailedError = class extends Error {
 export {
   buildDesktopHarnessInvocation,
   resolveDesktopHarnessRepoRoot,
-  runHarnessCommand
+  runDesktopTestCommand
 };