@plune-ai/cli 0.3.0 → 0.5.0

package/README.md

@@ -100,11 +100,30 @@ provider API key is read from the environment based on `provider.type`:
 | `plune report` | Re-render the most recent run. Flags: `--format`, `-o`. |
 | `plune diff <baseline> <current>` | Compare two `plune run --format json` outputs and report pass→fail regressions. Flags: `--fail-on-regression`, `--format`, `-o`. |
 | `plune init` | Scaffold `plune.yaml`, a sample dataset, and `.env.example`. Flags: `--yes` (non-interactive), `--force`. |
+| `plune login` | Save a [Plune platform](https://plune.ai/platform) API token so `sync` can reach it. Flags: `--token <token>` (omit to paste it or pipe it via stdin). |
+| `plune logout` | Remove the saved token. |
+| `plune sync` | Upload the latest local run to the platform. Flags: `--file <path>` to send a specific run JSON. |
 
 Global flags: `-c, --config <path>` · `-v, --verbose` · `--no-color`.
 
 **Exit codes:** `0` everything passed · `1` an assertion failed · `2` configuration or execution error.
 
+## Optional: keep a history
+
+Everything above works with no account, no network, and no token — that does not change. If you
+also want run history, trends, and a shared dashboard, the three cloud commands push your local
+runs to the [Plune platform](https://plune.ai/platform):
+
+```bash
+plune login          # paste the API token from your platform settings page
+plune run            # exactly as before — the run is saved locally
+plune sync           # upload .plune/last-run.json, print the read-back URL
+```
+
+The token is stored at `~/.config/plune/credentials.json` (mode `0600`, honours `XDG_CONFIG_HOME`)
+and is never printed or logged. `PLUNE_API_URL` points `sync` at a different server — useful for a
+self-hosted backend.
+
 ## Programmatic API
 
 The same engine that powers `plune run` is exported for use from your own code. Unlike the

package/dist/cli.cjs

@@ -483,7 +483,7 @@ var init_retry = __esm({
     "use strict";
     init_cjs_shims();
     init_errors2();
-    defaultSleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
+    defaultSleep = (ms) => new Promise((resolve6) => setTimeout(resolve6, ms));
   }
 });
 
@@ -2519,6 +2519,283 @@ var init_init = __esm({
   }
 });
 
+// src/cli/credentials.ts
+function credentialsFile() {
+  const base = process.env["XDG_CONFIG_HOME"]?.trim() || (0, import_node_path.join)((0, import_node_os.homedir)(), ".config");
+  return (0, import_node_path.join)(base, "plune", "credentials.json");
+}
+function saveToken(token) {
+  const file = credentialsFile();
+  (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(file), { recursive: true, mode: 448 });
+  (0, import_node_fs.writeFileSync)(file, JSON.stringify({ token }, null, 2) + "\n", { mode: 384 });
+  (0, import_node_fs.chmodSync)(file, 384);
+  return file;
+}
+function loadToken() {
+  try {
+    const parsed = JSON.parse((0, import_node_fs.readFileSync)(credentialsFile(), "utf-8"));
+    return typeof parsed.token === "string" && parsed.token.length > 0 ? parsed.token : null;
+  } catch {
+    return null;
+  }
+}
+function clearToken() {
+  const file = credentialsFile();
+  if (!(0, import_node_fs.existsSync)(file)) return { removed: false, path: file };
+  (0, import_node_fs.rmSync)(file);
+  return { removed: true, path: file };
+}
+var import_node_fs, import_node_os, import_node_path;
+var init_credentials = __esm({
+  "src/cli/credentials.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_node_fs = require("fs");
+    import_node_os = require("os");
+    import_node_path = require("path");
+  }
+});
+
+// src/cli/commands/login.ts
+var login_exports = {};
+__export(login_exports, {
+  EmptyTokenError: () => EmptyTokenError,
+  handleLogin: () => handleLogin
+});
+function handleLogin(opts) {
+  const token = opts.token.trim();
+  if (token.length === 0) throw new EmptyTokenError();
+  return { path: saveToken(token) };
+}
+var EmptyTokenError;
+var init_login = __esm({
+  "src/cli/commands/login.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_credentials();
+    EmptyTokenError = class extends Error {
+      constructor() {
+        super("No API token provided. Pass --token <token> or pipe it via stdin.");
+        this.name = "EmptyTokenError";
+      }
+    };
+  }
+});
+
+// src/cli/commands/logout.ts
+var logout_exports = {};
+__export(logout_exports, {
+  handleLogout: () => handleLogout
+});
+function handleLogout() {
+  return clearToken();
+}
+var init_logout = __esm({
+  "src/cli/commands/logout.ts"() {
+    "use strict";
+    init_cjs_shims();
+    init_credentials();
+  }
+});
+
+// src/types/run-result-schema.ts
+function parseRunResult(value) {
+  return runResultSchema.parse(value);
+}
+var import_zod2, RUN_RESULT_SCHEMA_VERSION, binaryVerdictSchema, assertionResultRecordSchema, usageSchema, runErrorSchema, rowResultSchema, summarySchema, evalResultSchema, runResultSchema;
+var init_run_result_schema = __esm({
+  "src/types/run-result-schema.ts"() {
+    "use strict";
+    init_cjs_shims();
+    import_zod2 = require("zod");
+    RUN_RESULT_SCHEMA_VERSION = 1;
+    binaryVerdictSchema = import_zod2.z.object({
+      question: import_zod2.z.string().min(1),
+      passed: import_zod2.z.boolean()
+    });
+    assertionResultRecordSchema = import_zod2.z.object({
+      type: import_zod2.z.string(),
+      passed: import_zod2.z.boolean(),
+      score: import_zod2.z.number().optional(),
+      reason: import_zod2.z.string().optional(),
+      binaryVerdicts: import_zod2.z.array(binaryVerdictSchema).optional()
+    });
+    usageSchema = import_zod2.z.object({
+      input_tokens: import_zod2.z.number(),
+      output_tokens: import_zod2.z.number(),
+      cost_usd: import_zod2.z.number()
+    });
+    runErrorSchema = import_zod2.z.object({
+      code: import_zod2.z.string(),
+      message: import_zod2.z.string()
+    });
+    rowResultSchema = import_zod2.z.object({
+      vars: import_zod2.z.record(import_zod2.z.unknown()),
+      output: import_zod2.z.string().nullable(),
+      cached: import_zod2.z.boolean(),
+      usage: usageSchema.optional(),
+      latency_ms: import_zod2.z.number().optional(),
+      error: runErrorSchema.optional(),
+      assertions: import_zod2.z.array(assertionResultRecordSchema)
+    });
+    summarySchema = import_zod2.z.object({
+      total: import_zod2.z.number(),
+      passed: import_zod2.z.number(),
+      failed: import_zod2.z.number(),
+      errored: import_zod2.z.number(),
+      cost_usd: import_zod2.z.number(),
+      duration_ms: import_zod2.z.number()
+    });
+    evalResultSchema = import_zod2.z.object({
+      id: import_zod2.z.string(),
+      tags: import_zod2.z.array(import_zod2.z.string()),
+      rows: import_zod2.z.array(rowResultSchema),
+      passed: import_zod2.z.boolean()
+    });
+    runResultSchema = import_zod2.z.object({
+      schemaVersion: import_zod2.z.literal(RUN_RESULT_SCHEMA_VERSION),
+      plune_version: import_zod2.z.string(),
+      started_at: import_zod2.z.string(),
+      finished_at: import_zod2.z.string(),
+      config_hash: import_zod2.z.string(),
+      summary: summarySchema,
+      evals: import_zod2.z.array(evalResultSchema)
+    });
+  }
+});
+
+// src/cli/commands/sync.ts
+var sync_exports = {};
+__export(sync_exports, {
+  NotLoggedInError: () => NotLoggedInError,
+  SyncFileError: () => SyncFileError,
+  SyncHttpError: () => SyncHttpError,
+  SyncNetworkError: () => SyncNetworkError,
+  TokenRejectedError: () => TokenRejectedError,
+  handleSync: () => handleSync,
+  reportSyncFailure: () => reportSyncFailure
+});
+function resolveApiUrl(explicit) {
+  const raw = explicit ?? process.env["PLUNE_API_URL"] ?? DEFAULT_API_URL;
+  return raw.replace(/\/+$/, "");
+}
+function readRun(cwd, file) {
+  const target = file !== void 0 ? path9.resolve(cwd, file) : path9.join(cwd, ".plune", "last-run.json");
+  let raw;
+  try {
+    raw = fs10.readFileSync(target, "utf8");
+  } catch {
+    throw new SyncFileError(
+      file !== void 0 ? `Run file not found: ${target}` : 'No run to sync. Run "plune run" first (or pass --file <path>).'
+    );
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    throw new SyncFileError(`Run file is not valid JSON: ${target}`);
+  }
+  try {
+    return parseRunResult(json);
+  } catch {
+    throw new SyncFileError(`Run file does not match the RunResult schema: ${target}`);
+  }
+}
+async function safeErrorDetail(res) {
+  try {
+    const body = await res.json();
+    return typeof body.error === "string" ? body.error : "";
+  } catch {
+    return "";
+  }
+}
+async function handleSync(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const apiUrl = resolveApiUrl(deps.apiUrl);
+  const token = (deps.loadToken ?? loadToken)();
+  if (token === null) throw new NotLoggedInError();
+  const run = readRun(cwd, deps.file);
+  const doFetch = deps.fetchImpl ?? fetch;
+  const endpoint = `${apiUrl}/v1/runs`;
+  let res;
+  try {
+    res = await doFetch(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+      body: JSON.stringify(run)
+    });
+  } catch {
+    throw new SyncNetworkError(apiUrl);
+  }
+  if (!res.ok) {
+    const detail = await safeErrorDetail(res);
+    if (res.status === 401) throw new TokenRejectedError();
+    throw new SyncHttpError(res.status, detail);
+  }
+  const body = await res.json().catch(() => ({}));
+  const id = typeof body.id === "string" ? body.id : "";
+  return { id, url: `${endpoint}/${id}` };
+}
+function reportSyncFailure(err, write) {
+  if (err instanceof NotLoggedInError || err instanceof TokenRejectedError || err instanceof SyncFileError) {
+    write(err.message + "\n");
+    return 2;
+  }
+  if (err instanceof SyncNetworkError || err instanceof SyncHttpError) {
+    write(err.message + "\n");
+    return 1;
+  }
+  return null;
+}
+var fs10, path9, DEFAULT_API_URL, NotLoggedInError, TokenRejectedError, SyncFileError, SyncNetworkError, SyncHttpError;
+var init_sync = __esm({
+  "src/cli/commands/sync.ts"() {
+    "use strict";
+    init_cjs_shims();
+    fs10 = __toESM(require("fs"), 1);
+    path9 = __toESM(require("path"), 1);
+    init_run_result_schema();
+    init_credentials();
+    DEFAULT_API_URL = "https://beta-api.plune.ai";
+    NotLoggedInError = class extends Error {
+      constructor() {
+        super('Not logged in. Run "plune login" first to save your API token.');
+        this.name = "NotLoggedInError";
+      }
+    };
+    TokenRejectedError = class extends Error {
+      constructor() {
+        super(
+          'Your API token was rejected (revoked or invalid). Run "plune login" with a fresh token.'
+        );
+        this.name = "TokenRejectedError";
+      }
+    };
+    SyncFileError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "SyncFileError";
+      }
+    };
+    SyncNetworkError = class extends Error {
+      constructor(apiUrl) {
+        super(
+          `Could not reach the Plune API at ${apiUrl}. Check your connection (or PLUNE_API_URL) and try again.`
+        );
+        this.name = "SyncNetworkError";
+      }
+    };
+    SyncHttpError = class extends Error {
+      constructor(status, detail) {
+        super(`Sync failed \u2014 the server returned HTTP ${status}${detail ? ` (${detail})` : ""}.`);
+        this.status = status;
+        this.name = "SyncHttpError";
+      }
+      status;
+    };
+  }
+});
+
 // src/cli.ts
 var cli_exports = {};
 __export(cli_exports, {
@@ -2527,11 +2804,11 @@ __export(cli_exports, {
 module.exports = __toCommonJS(cli_exports);
 init_cjs_shims();
 var import_commander = require("commander");
-var import_node_fs = require("fs");
-var import_node_path = require("path");
+var import_node_fs2 = require("fs");
+var import_node_path2 = require("path");
 var import_node_url = require("url");
-var __dirname = (0, import_node_path.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
-var pkg = JSON.parse((0, import_node_fs.readFileSync)((0, import_node_path.join)(__dirname, "..", "package.json"), "utf-8"));
+var __dirname = (0, import_node_path2.dirname)((0, import_node_url.fileURLToPath)(importMetaUrl));
+var pkg = JSON.parse((0, import_node_fs2.readFileSync)((0, import_node_path2.join)(__dirname, "..", "package.json"), "utf-8"));
 function toFormat(s) {
   return s === "json" || s === "markdown" ? s : "console";
 }
@@ -2540,7 +2817,7 @@ function shouldColor(outputPath) {
 }
 function writeReport(text2, outputPath) {
   if (outputPath !== void 0) {
-    (0, import_node_fs.writeFileSync)(outputPath, text2);
+    (0, import_node_fs2.writeFileSync)(outputPath, text2);
   } else {
     process.stdout.write(text2 + "\n");
   }
@@ -2558,6 +2835,19 @@ function failUnexpected(err, verbose) {
   }
   process.exit(1);
 }
+async function readTokenFromStdin() {
+  if (process.stdin.isTTY === true) {
+    process.stderr.write("Paste your API token, then press Enter:\n");
+  }
+  const { createInterface } = await import("readline");
+  const rl = createInterface({ input: process.stdin });
+  try {
+    for await (const line of rl) return line;
+    return "";
+  } finally {
+    rl.close();
+  }
+}
 function createProgram() {
   const program = new import_commander.Command();
   program.name("plune").description("Plune \u2014 AI-powered assertion testing CLI").version(pkg.version);
@@ -2586,7 +2876,7 @@ function createProgram() {
         Promise.resolve().then(() => (init_errors(), errors_exports)),
         Promise.resolve().then(() => (init_errors2(), errors_exports2))
       ]);
-      loadEnv2(configPath !== void 0 ? (0, import_node_path.dirname)((0, import_node_path.resolve)(configPath)) : process.cwd());
+      loadEnv2(configPath !== void 0 ? (0, import_node_path2.dirname)((0, import_node_path2.resolve)(configPath)) : process.cwd());
       try {
         const result = await handleRun2({
           dryRun: options.dryRun,
@@ -2645,7 +2935,7 @@ function createProgram() {
       Promise.resolve().then(() => (init_report(), report_exports)),
       Promise.resolve().then(() => (init_reporters(), reporters_exports))
     ]);
-    const cwd = globals.config !== void 0 ? (0, import_node_path.dirname)((0, import_node_path.resolve)(globals.config)) : process.cwd();
+    const cwd = globals.config !== void 0 ? (0, import_node_path2.dirname)((0, import_node_path2.resolve)(globals.config)) : process.cwd();
     loadEnv2(cwd);
     try {
       const result = handleReport2({ cwd });
@@ -2701,6 +2991,58 @@ function createProgram() {
       failUnexpected(err, verbose);
     }
   });
+  program.command("login").description("Save your Plune API token so the CLI can reach the platform").option("--token <token>", "API token (omit to paste it / pipe it via stdin)").action(async (options, command) => {
+    const verbose = command.optsWithGlobals().verbose === true;
+    const { handleLogin: handleLogin2, EmptyTokenError: EmptyTokenError2 } = await Promise.resolve().then(() => (init_login(), login_exports));
+    try {
+      const token = options.token ?? await readTokenFromStdin();
+      const { path: path10 } = handleLogin2({ token });
+      process.stdout.write(`Logged in. Token saved to ${path10}
+`);
+    } catch (err) {
+      if (err instanceof EmptyTokenError2) {
+        process.stderr.write(err.message + "\n");
+        process.exit(2);
+        return;
+      }
+      failUnexpected(err, verbose);
+    }
+  });
+  program.command("logout").description("Remove the saved Plune API token").action(async (_options, command) => {
+    const verbose = command.optsWithGlobals().verbose === true;
+    const { handleLogout: handleLogout2 } = await Promise.resolve().then(() => (init_logout(), logout_exports));
+    try {
+      const { removed, path: path10 } = handleLogout2();
+      process.stdout.write(
+        removed ? `Logged out. Removed ${path10}
+` : "Not logged in \u2014 nothing to remove.\n"
+      );
+    } catch (err) {
+      failUnexpected(err, verbose);
+    }
+  });
+  program.command("sync").description("Upload your latest local run to the Plune platform (POST /v1/runs)").option("--file <path>", "Sync a specific run JSON instead of .plune/last-run.json").action(async (options, command) => {
+    const globals = command.optsWithGlobals();
+    const verbose = globals.verbose === true;
+    const { handleSync: handleSync2, reportSyncFailure: reportSyncFailure2 } = await Promise.resolve().then(() => (init_sync(), sync_exports));
+    const cwd = globals.config !== void 0 ? (0, import_node_path2.dirname)((0, import_node_path2.resolve)(globals.config)) : process.cwd();
+    try {
+      const { id, url } = await handleSync2({
+        cwd,
+        ...options.file !== void 0 ? { file: options.file } : {}
+      });
+      process.stdout.write(`Synced run ${id} \u2192 ${url}
+`);
+    } catch (err) {
+      const code = reportSyncFailure2(err, (s) => process.stderr.write(s));
+      if (code !== null) {
+        maybeStack(err, verbose);
+        process.exitCode = code;
+        return;
+      }
+      failUnexpected(err, verbose);
+    }
+  });
   program.on("command:*", (operands) => {
     process.stderr.write(`Unknown command: ${operands.join(" ")}
 `);
@@ -2712,7 +3054,7 @@ function isMainModule() {
   const entry = process.argv[1];
   if (entry === void 0) return false;
   try {
-    return (0, import_node_fs.realpathSync)(entry) === (0, import_node_fs.realpathSync)((0, import_node_url.fileURLToPath)(importMetaUrl));
+    return (0, import_node_fs2.realpathSync)(entry) === (0, import_node_fs2.realpathSync)((0, import_node_url.fileURLToPath)(importMetaUrl));
   } catch {
     return false;
   }

package/dist/index.cjs

@@ -30,7 +30,20 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  run: () => handleRun
+  NotLoggedInError: () => NotLoggedInError,
+  RUN_RESULT_SCHEMA_VERSION: () => RUN_RESULT_SCHEMA_VERSION,
+  SyncFileError: () => SyncFileError,
+  SyncHttpError: () => SyncHttpError,
+  SyncNetworkError: () => SyncNetworkError,
+  TokenRejectedError: () => TokenRejectedError,
+  assertionConfigSchema: () => assertionConfigSchema,
+  assertionResultRecordSchema: () => assertionResultRecordSchema,
+  binaryVerdictSchema: () => binaryVerdictSchema,
+  parseRunResult: () => parseRunResult,
+  reportSyncFailure: () => reportSyncFailure,
+  run: () => handleRun,
+  runResultSchema: () => runResultSchema,
+  sync: () => handleSync
 });
 module.exports = __toCommonJS(src_exports);
 
@@ -351,7 +364,7 @@ function normalizeProviderError(err, secret, envVar) {
 }
 
 // src/providers/retry.ts
-var defaultSleep = (ms) => new Promise((resolve4) => setTimeout(resolve4, ms));
+var defaultSleep = (ms) => new Promise((resolve5) => setTimeout(resolve5, ms));
 function retryAfterMs(err) {
   if (typeof err !== "object" || err === null || !("headers" in err)) return void 0;
   const raw = readHeader(err.headers, "retry-after");
@@ -1496,7 +1509,211 @@ async function handleRun(options, depsFactory) {
     deps.cache.close();
   }
 }
+
+// src/cli/commands/sync.ts
+var fs6 = __toESM(require("fs"), 1);
+var path5 = __toESM(require("path"), 1);
+
+// src/types/run-result-schema.ts
+var import_zod2 = require("zod");
+var RUN_RESULT_SCHEMA_VERSION = 1;
+var binaryVerdictSchema = import_zod2.z.object({
+  question: import_zod2.z.string().min(1),
+  passed: import_zod2.z.boolean()
+});
+var assertionResultRecordSchema = import_zod2.z.object({
+  type: import_zod2.z.string(),
+  passed: import_zod2.z.boolean(),
+  score: import_zod2.z.number().optional(),
+  reason: import_zod2.z.string().optional(),
+  binaryVerdicts: import_zod2.z.array(binaryVerdictSchema).optional()
+});
+var usageSchema = import_zod2.z.object({
+  input_tokens: import_zod2.z.number(),
+  output_tokens: import_zod2.z.number(),
+  cost_usd: import_zod2.z.number()
+});
+var runErrorSchema = import_zod2.z.object({
+  code: import_zod2.z.string(),
+  message: import_zod2.z.string()
+});
+var rowResultSchema = import_zod2.z.object({
+  vars: import_zod2.z.record(import_zod2.z.unknown()),
+  output: import_zod2.z.string().nullable(),
+  cached: import_zod2.z.boolean(),
+  usage: usageSchema.optional(),
+  latency_ms: import_zod2.z.number().optional(),
+  error: runErrorSchema.optional(),
+  assertions: import_zod2.z.array(assertionResultRecordSchema)
+});
+var summarySchema = import_zod2.z.object({
+  total: import_zod2.z.number(),
+  passed: import_zod2.z.number(),
+  failed: import_zod2.z.number(),
+  errored: import_zod2.z.number(),
+  cost_usd: import_zod2.z.number(),
+  duration_ms: import_zod2.z.number()
+});
+var evalResultSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  tags: import_zod2.z.array(import_zod2.z.string()),
+  rows: import_zod2.z.array(rowResultSchema),
+  passed: import_zod2.z.boolean()
+});
+var runResultSchema = import_zod2.z.object({
+  schemaVersion: import_zod2.z.literal(RUN_RESULT_SCHEMA_VERSION),
+  plune_version: import_zod2.z.string(),
+  started_at: import_zod2.z.string(),
+  finished_at: import_zod2.z.string(),
+  config_hash: import_zod2.z.string(),
+  summary: summarySchema,
+  evals: import_zod2.z.array(evalResultSchema)
+});
+function parseRunResult(value) {
+  return runResultSchema.parse(value);
+}
+
+// src/cli/credentials.ts
+var import_node_fs = require("fs");
+var import_node_os = require("os");
+var import_node_path = require("path");
+function credentialsFile() {
+  const base = process.env["XDG_CONFIG_HOME"]?.trim() || (0, import_node_path.join)((0, import_node_os.homedir)(), ".config");
+  return (0, import_node_path.join)(base, "plune", "credentials.json");
+}
+function loadToken() {
+  try {
+    const parsed = JSON.parse((0, import_node_fs.readFileSync)(credentialsFile(), "utf-8"));
+    return typeof parsed.token === "string" && parsed.token.length > 0 ? parsed.token : null;
+  } catch {
+    return null;
+  }
+}
+
+// src/cli/commands/sync.ts
+var DEFAULT_API_URL = "https://beta-api.plune.ai";
+var NotLoggedInError = class extends Error {
+  constructor() {
+    super('Not logged in. Run "plune login" first to save your API token.');
+    this.name = "NotLoggedInError";
+  }
+};
+var TokenRejectedError = class extends Error {
+  constructor() {
+    super(
+      'Your API token was rejected (revoked or invalid). Run "plune login" with a fresh token.'
+    );
+    this.name = "TokenRejectedError";
+  }
+};
+var SyncFileError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "SyncFileError";
+  }
+};
+var SyncNetworkError = class extends Error {
+  constructor(apiUrl) {
+    super(
+      `Could not reach the Plune API at ${apiUrl}. Check your connection (or PLUNE_API_URL) and try again.`
+    );
+    this.name = "SyncNetworkError";
+  }
+};
+var SyncHttpError = class extends Error {
+  constructor(status, detail) {
+    super(`Sync failed \u2014 the server returned HTTP ${status}${detail ? ` (${detail})` : ""}.`);
+    this.status = status;
+    this.name = "SyncHttpError";
+  }
+  status;
+};
+function resolveApiUrl(explicit) {
+  const raw = explicit ?? process.env["PLUNE_API_URL"] ?? DEFAULT_API_URL;
+  return raw.replace(/\/+$/, "");
+}
+function readRun(cwd, file) {
+  const target = file !== void 0 ? path5.resolve(cwd, file) : path5.join(cwd, ".plune", "last-run.json");
+  let raw;
+  try {
+    raw = fs6.readFileSync(target, "utf8");
+  } catch {
+    throw new SyncFileError(
+      file !== void 0 ? `Run file not found: ${target}` : 'No run to sync. Run "plune run" first (or pass --file <path>).'
+    );
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    throw new SyncFileError(`Run file is not valid JSON: ${target}`);
+  }
+  try {
+    return parseRunResult(json);
+  } catch {
+    throw new SyncFileError(`Run file does not match the RunResult schema: ${target}`);
+  }
+}
+async function safeErrorDetail(res) {
+  try {
+    const body = await res.json();
+    return typeof body.error === "string" ? body.error : "";
+  } catch {
+    return "";
+  }
+}
+async function handleSync(deps = {}) {
+  const cwd = deps.cwd ?? process.cwd();
+  const apiUrl = resolveApiUrl(deps.apiUrl);
+  const token = (deps.loadToken ?? loadToken)();
+  if (token === null) throw new NotLoggedInError();
+  const run = readRun(cwd, deps.file);
+  const doFetch = deps.fetchImpl ?? fetch;
+  const endpoint = `${apiUrl}/v1/runs`;
+  let res;
+  try {
+    res = await doFetch(endpoint, {
+      method: "POST",
+      headers: { "content-type": "application/json", authorization: `Bearer ${token}` },
+      body: JSON.stringify(run)
+    });
+  } catch {
+    throw new SyncNetworkError(apiUrl);
+  }
+  if (!res.ok) {
+    const detail = await safeErrorDetail(res);
+    if (res.status === 401) throw new TokenRejectedError();
+    throw new SyncHttpError(res.status, detail);
+  }
+  const body = await res.json().catch(() => ({}));
+  const id = typeof body.id === "string" ? body.id : "";
+  return { id, url: `${endpoint}/${id}` };
+}
+function reportSyncFailure(err, write) {
+  if (err instanceof NotLoggedInError || err instanceof TokenRejectedError || err instanceof SyncFileError) {
+    write(err.message + "\n");
+    return 2;
+  }
+  if (err instanceof SyncNetworkError || err instanceof SyncHttpError) {
+    write(err.message + "\n");
+    return 1;
+  }
+  return null;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  run
+  NotLoggedInError,
+  RUN_RESULT_SCHEMA_VERSION,
+  SyncFileError,
+  SyncHttpError,
+  SyncNetworkError,
+  TokenRejectedError,
+  assertionConfigSchema,
+  assertionResultRecordSchema,
+  binaryVerdictSchema,
+  parseRunResult,
+  reportSyncFailure,
+  run,
+  runResultSchema,
+  sync
 });