openpond 0.0.38 → 0.0.39

package/dist/chunks/{teams-bot-PSL3ZO6Z.js → teams-bot-NTQ6VFFL.js}

@@ -1,10 +1,12 @@
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
   resolveSandboxClient
-} from "./chunk-275WCETC.js";
-import "./chunk-GDZYDLEL.js";
-import "./chunk-XCATKTK3.js";
-import "./chunk-ZI4GDAUB.js";
+} from "./chunk-FCVVOMIP.js";
+import "./chunk-KHNHUA2H.js";
+import "./chunk-JRROTGQT.js";
+import "./chunk-SMNFI2FU.js";
+import "./chunk-3CDPPVLE.js";
+import "./chunk-DBHSOTYZ.js";
 import "./chunk-KSRWKXRB.js";
 import {
   optionString,

package/dist/chunks/training-BR5A7SPU.js

@@ -0,0 +1,320 @@
+import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
+import {
+  resolveApiBaseUrlOption
+} from "./chunk-SMNFI2FU.js";
+import "./chunk-KSRWKXRB.js";
+import {
+  optionString,
+  parseBooleanOption,
+  parseIntegerOption,
+  parseNumberOption
+} from "./chunk-MUMPWI4O.js";
+import "./chunk-UACZUFIA.js";
+
+// src/cli/training.ts
+import { readFile } from "node:fs/promises";
+import { request as requestHttp } from "node:http";
+import os from "node:os";
+import path from "node:path";
+import { createInterface } from "node:readline/promises";
+var DEFAULT_LOCAL_TRAINING_API_URL = "http://127.0.0.1:17874";
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set([
+  "cancelled",
+  "completed",
+  "failed",
+  "succeeded"
+]);
+async function runTrainingCommand(options, rest, dependencies = {}) {
+  const subcommand = rest[0];
+  const id = rest[1];
+  if (!subcommand || ![
+    "start",
+    "status",
+    "watch",
+    "logs",
+    "cancel",
+    "artifacts"
+  ].includes(
+    subcommand
+  ) || !id) {
+    throw new Error(
+      "usage: training <start|status|watch|logs|cancel|artifacts> <model-run-id|run-id>"
+    );
+  }
+  if (rest.length > 2) {
+    throw new Error(`training ${subcommand} accepts exactly one identifier`);
+  }
+  const baseUrl = resolveApiBaseUrlOption(options) ?? process.env.OPENPOND_LOCAL_API_URL?.replace(/\/$/, "") ?? DEFAULT_LOCAL_TRAINING_API_URL;
+  const client = new TrainingApiClient({
+    baseUrl,
+    request: dependencies.request ?? await createLocalAuthenticatedRequest(baseUrl)
+  });
+  const json = parseBooleanOption(options.json);
+  if (subcommand === "start") {
+    await startTraining({
+      client,
+      dependencies,
+      json,
+      modelRunId: id,
+      options
+    });
+    return;
+  }
+  if (subcommand === "watch") {
+    await watchTraining({
+      client,
+      runId: id,
+      json,
+      intervalMs: parseIntegerOption(options.intervalMs, "interval-ms") ?? 2e3,
+      sleep: dependencies.sleep
+    });
+    return;
+  }
+  const endpoint = subcommand === "status" ? "status" : subcommand === "logs" ? "logs" : subcommand === "artifacts" ? "artifacts" : "cancel";
+  const result = await client.modelRun(
+    id,
+    endpoint,
+    subcommand === "cancel" ? "POST" : "GET"
+  );
+  printResult(result, json);
+}
+async function createLocalAuthenticatedRequest(baseUrl) {
+  const url = new URL(baseUrl);
+  if (url.protocol !== "http:" || !["127.0.0.1", "localhost", "::1"].includes(url.hostname)) {
+    return fetch;
+  }
+  const appHome = process.env.OPENPOND_APP_HOME?.trim() || path.join(os.homedir(), ".openpond", "openpond-app");
+  const token = (await readFile(path.join(appHome, "token"), "utf8")).trim();
+  if (!token) {
+    throw new Error("OpenPond local capability token is empty.");
+  }
+  return (async (resource, init = {}) => {
+    const target = resource instanceof Request ? new URL(resource.url) : new URL(String(resource));
+    const headers = new Headers(init.headers);
+    headers.set("authorization", `Bearer ${token}`);
+    const nodeHeaders = {};
+    headers.forEach((value, name) => {
+      nodeHeaders[name] = value;
+    });
+    return new Promise((resolve, reject) => {
+      let settled = false;
+      const request = requestHttp(
+        target,
+        {
+          method: init.method ?? "GET",
+          headers: nodeHeaders
+        },
+        (response) => {
+          const chunks = [];
+          response.on("data", (chunk) => chunks.push(chunk));
+          response.once("error", rejectOnce);
+          response.once("end", () => {
+            if (settled) return;
+            settled = true;
+            const responseHeaders = new Headers();
+            for (const [name, value] of Object.entries(response.headers)) {
+              if (Array.isArray(value)) {
+                for (const item of value) responseHeaders.append(name, item);
+              } else if (value !== void 0) {
+                responseHeaders.set(name, value);
+              }
+            }
+            resolve(
+              new Response(new Uint8Array(Buffer.concat(chunks)), {
+                status: response.statusCode ?? 500,
+                statusText: response.statusMessage,
+                headers: responseHeaders
+              })
+            );
+          });
+        }
+      );
+      const rejectOnce = (error) => {
+        if (settled) return;
+        settled = true;
+        reject(error);
+      };
+      request.once("error", rejectOnce);
+      if (init.signal) {
+        const abort = () => request.destroy(
+          init.signal?.reason instanceof Error ? init.signal.reason : new Error("Training API request aborted.")
+        );
+        if (init.signal.aborted) abort();
+        else init.signal.addEventListener("abort", abort, { once: true });
+      }
+      if (init.body !== void 0 && init.body !== null) {
+        if (typeof init.body !== "string" && !(init.body instanceof Uint8Array)) {
+          request.destroy(
+            new Error("Local Training API supports string or byte request bodies.")
+          );
+          return;
+        }
+        request.write(init.body);
+      }
+      request.end();
+    });
+  });
+}
+var TrainingApiClient = class {
+  baseUrl;
+  request;
+  constructor(input) {
+    this.baseUrl = input.baseUrl.replace(/\/$/, "");
+    this.request = input.request ?? fetch;
+  }
+  modelRun(id, action, method, body) {
+    return this.json(
+      `/v1/training/model-runs/${encodeURIComponent(id)}/${action}`,
+      method,
+      body
+    );
+  }
+  async json(pathname, method, body) {
+    const response = await this.request(`${this.baseUrl}${pathname}`, {
+      method,
+      headers: body === void 0 ? { Accept: "application/json" } : {
+        Accept: "application/json",
+        "Content-Type": "application/json"
+      },
+      body: body === void 0 ? void 0 : JSON.stringify(body)
+    });
+    const text = await response.text();
+    let payload = null;
+    if (text) {
+      try {
+        payload = JSON.parse(text);
+      } catch {
+        payload = text;
+      }
+    }
+    if (!response.ok) {
+      const message = payload && typeof payload === "object" && "error" in payload && typeof payload.error === "string" ? payload.error : `${response.status} ${response.statusText}`.trim();
+      throw new Error(`Training API request failed: ${message}`);
+    }
+    return payload;
+  }
+};
+async function startTraining(input) {
+  const maximumSpendUsd = parseNumberOption(
+    input.options.maxSpend,
+    "max-spend"
+  ) ?? null;
+  if (maximumSpendUsd !== null && maximumSpendUsd < 0) {
+    throw new Error("max-spend must be non-negative");
+  }
+  const retentionDays = parseIntegerOption(input.options.retentionDays, "retention-days") ?? null;
+  if (retentionDays !== null && retentionDays <= 0) {
+    throw new Error("retention-days must be a positive integer");
+  }
+  const manifestPath = optionString(input.options, "manifest");
+  const manifest = manifestPath ? await readManifest(manifestPath) : void 0;
+  const controls = { maximumSpendUsd, retentionDays };
+  const preparation = await input.client.modelRun(
+    input.modelRunId,
+    "prepare",
+    "POST",
+    controls
+  );
+  if (!input.json) {
+    console.log("Preparation:");
+    console.log(JSON.stringify(preparation, null, 2));
+  }
+  const confirmed = parseBooleanOption(input.options.yes) || await confirmStart(input.dependencies.confirm);
+  if (!confirmed) {
+    throw new Error("Training start cancelled.");
+  }
+  const result = await input.client.modelRun(
+    input.modelRunId,
+    "start",
+    "POST",
+    { ...controls, manifest }
+  );
+  printResult(result, input.json);
+  if (parseBooleanOption(input.options.detach)) return;
+  const runId = readRunId(result) ?? input.modelRunId;
+  await watchTraining({
+    client: input.client,
+    runId,
+    json: input.json,
+    intervalMs: 2e3,
+    sleep: input.dependencies.sleep
+  });
+}
+async function watchTraining(input) {
+  if (input.intervalMs < 250) {
+    throw new Error("interval-ms must be at least 250");
+  }
+  const sleep = input.sleep ?? ((milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)));
+  let previous = "";
+  for (; ; ) {
+    const status = await input.client.modelRun(
+      input.runId,
+      "status",
+      "GET"
+    );
+    const serialized = JSON.stringify(status);
+    if (input.json || serialized !== previous) {
+      printResult(status, input.json);
+      previous = serialized;
+    }
+    if (TERMINAL_STATUSES.has(readStatus(status))) return;
+    await sleep(input.intervalMs);
+  }
+}
+async function readManifest(path2) {
+  let parsed;
+  try {
+    parsed = JSON.parse(await readFile(path2, "utf8"));
+  } catch (error) {
+    throw new Error(
+      `Could not read Harness Run Manifest ${path2}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Harness Run Manifest must be a JSON object.");
+  }
+  return parsed;
+}
+async function confirmStart(injected) {
+  const message = "Start this exact prepared training run? Downloads, provisioning, or spend may begin.";
+  if (injected) return injected(message);
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    throw new Error(
+      "training start requires --yes when standard input is not interactive"
+    );
+  }
+  const prompt = createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  try {
+    const answer = await prompt.question(`${message} [y/N] `);
+    return answer.trim().toLowerCase() === "y" || answer.trim().toLowerCase() === "yes";
+  } finally {
+    prompt.close();
+  }
+}
+function readRunId(value) {
+  if (!value || typeof value !== "object") return null;
+  const job = "job" in value ? value.job : null;
+  if (!job || typeof job !== "object" || !("id" in job)) return null;
+  return typeof job.id === "string" ? job.id : null;
+}
+function readStatus(value) {
+  if (!value || typeof value !== "object") return "";
+  if ("state" in value && typeof value.state === "string") {
+    return value.state;
+  }
+  return "status" in value && typeof value.status === "string" ? value.status : "";
+}
+function printResult(value, json) {
+  if (json) {
+    console.log(JSON.stringify(value));
+    return;
+  }
+  console.log(JSON.stringify(value, null, 2));
+}
+export {
+  TrainingApiClient,
+  runTrainingCommand
+};

package/dist/chunks/{workspaces-BPXC2DHT.js → workspaces-XC3QBD2Y.js}

@@ -45,8 +45,8 @@ import {
   truncatePatch,
   uniqueSortedPaths,
   workspaceImageContentType
-} from "./chunk-AHNFNWUN.js";
-import "./chunk-HS2AGRDV.js";
+} from "./chunk-L6XH4ZGZ.js";
+import "./chunk-JJPAMKXZ.js";
 import "./chunk-UACZUFIA.js";
 export {
   MACOS_GIT_MISSING_DEVELOPER_TOOLS_ERROR,

package/dist/cli.js

@@ -1,14 +1,16 @@
 #!/usr/bin/env node
 import { createRequire as __openpondCreateRequire } from "node:module"; var require = __openpondCreateRequire(import.meta.url);
 import {
-  parseArgs,
+  parseArgs
+} from "./chunks/chunk-JRROTGQT.js";
+import {
   resolveAccountOption,
   resolveBaseUrlOption
-} from "./chunks/chunk-GDZYDLEL.js";
+} from "./chunks/chunk-SMNFI2FU.js";
 import {
   getInstalledCliVersion,
   runCliCommand
-} from "./chunks/chunk-XCATKTK3.js";
+} from "./chunks/chunk-3CDPPVLE.js";
 import "./chunks/chunk-KSRWKXRB.js";
 import {
   parseBooleanOption
@@ -35,11 +37,11 @@ async function runOpenPondCli(argv = process.argv.slice(2)) {
     return;
   }
   if (action === "check-update") {
-    await (await import("./chunks/core-commands-YN4RMWA3.js")).runCheckUpdate();
+    await (await import("./chunks/core-commands-4MRJQZJV.js")).runCheckUpdate();
     return;
   }
   if (action === "help") {
-    (await import("./chunks/help-VREQNA4I.js")).printHelp();
+    (await import("./chunks/help-LWNREJ7U.js")).printHelp();
     return;
   }
   const selectedAccount = resolveAccountOption(options);
@@ -51,31 +53,41 @@ async function runOpenPondCli(argv = process.argv.slice(2)) {
     process.env.OPENPOND_BASE_URL = selectedBaseUrl;
   }
   if (action === "tui") {
-    await (await import("./chunks/app-layer-DPUJRNO2.js")).runOpenPondTerminalCommand(options, rest);
+    await (await import("./chunks/app-layer-LTBWNA2F.js")).runOpenPondTerminalCommand(options, rest);
     return;
   }
   if (action === "ui") {
-    await (await import("./chunks/app-layer-DPUJRNO2.js")).runOpenPondServerCommand("web", options, rest);
+    await (await import("./chunks/app-layer-LTBWNA2F.js")).runOpenPondServerCommand("web", options, rest);
     return;
   }
   if (await runCliCommand({ command, options, rest })) {
     return;
   }
-  (await import("./chunks/help-VREQNA4I.js")).printHelp();
+  (await import("./chunks/help-LWNREJ7U.js")).printHelp();
   process.exit(1);
 }
 async function runEmbeddedCompanion(argv) {
+  if (argv[0] === "__app-server") {
+    process.argv = [process.execPath, "openpond-app-server", ...argv.slice(1)];
+    const [{ createOpenPondAppServer }, { runOpenPondAppServerCli }] = await Promise.all([
+      import("./chunks/app-server-runtime-VYYJ2AWX.js"),
+      import("./chunks/cli-JS76LCW2.js")
+    ]);
+    await runOpenPondAppServerCli(createOpenPondAppServer);
+    return true;
+  }
   if (argv[0] === "__server") {
     process.argv = [process.execPath, "openpond-server", ...argv.slice(1)];
     const [{ createOpenPondServer }, { runOpenPondServerCli }] = await Promise.all([
-      import("./chunks/src-MWDIK56B.js"),
-      import("./chunks/cli-7BKDWFNU.js")
+      import("./chunks/src-IC5RX4L6.js"),
+      import("./chunks/cli-JS76LCW2.js")
     ]);
-    await runOpenPondServerCli(createOpenPondServer);
+    const { createOpenPondAppServer } = await import("./chunks/app-server-runtime-VYYJ2AWX.js");
+    await runOpenPondServerCli({ createOpenPondServer, createOpenPondAppServer });
     return true;
   }
   if (argv[0] === "__terminal") {
-    await (await import("./chunks/src-RPW5TOPI.js")).runOpenPondTerminalCli(argv.slice(1));
+    await (await import("./chunks/src-ESAILPUH.js")).runOpenPondTerminalCli(argv.slice(1));
     return true;
   }
   return false;

package/dist/config.d.ts

@@ -26,7 +26,6 @@ export type LocalOpenPondProfileCheckStatus = {
 export type LocalOpenPondProfileHostedSourceCheckStatus = {
     status: string;
     agentId?: string | null;
-    workItemId?: string | null;
     deployPlanStatus?: string | null;
     canRun?: boolean | null;
     canDeploy?: boolean | null;
@@ -126,13 +125,20 @@ export type LocalOpenPondProfileConfig = {
     mode: "local";
     lastCheck?: LocalOpenPondProfileCheckStatus;
     lastPush?: LocalOpenPondProfilePushStatus;
+    profiles?: LocalOpenPondProfileCatalogEntry[];
+};
+export type LocalOpenPondProfileCatalogEntry = {
+    source: "local" | "github" | "openpond_git";
+    repositoryId: string;
+    repoPath: string;
+    profile: string;
+    lastCheck?: LocalOpenPondProfileCheckStatus;
+    lastPush?: LocalOpenPondProfilePushStatus;
 };
-export type LocalGoalStorageLocation = "global" | "workspace";
 export type LocalConfig = {
     accounts?: LocalAccountConfig[];
     activeProfile?: ActiveProfileSelector;
     openpondProfile?: LocalOpenPondProfileConfig;
-    goalStorageLocation?: LocalGoalStorageLocation;
     baseUrl?: string;
     apiBaseUrl?: string;
     chatApiBaseUrl?: string;