@withgauge/cli 0.26.0 → 0.28.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -206,7 +206,7 @@ describe the transport and person-profile behavior.
206
206
  For an end-to-end improvement loop, run `gauge instructions hillclimb`. It guides
207
207
  your coding agent to identify product inputs, propose a representative pilot,
208
208
  inspect and publish findings, implement a focused change, and rerun to compare.
209
- Init and the generated `AGENTS.md` point to this guidance. `gauge install-skill`
209
+ Init and the `AGENTS.md` block from `init --cases` point to this guidance. `gauge install-skill`
210
210
  installs the Gauge skill, which directs agents to the installed CLI's instructions.
211
211
 
212
212
  Execution backend is independent of definition source. Resolve an explicit
@@ -264,6 +264,7 @@ target; `--copy` copies files instead of creating symlinks.
264
264
  ## Usage
265
265
 
266
266
  ```sh
267
+ gauge run "Which CLI should I deploy with?" # one open-ended preference run, nothing saved
267
268
  gauge status # the org at a glance
268
269
  gauge eval list # saved eval sets
269
270
  gauge preference list # saved Agent Preference prompts
@@ -392,7 +393,7 @@ alongside your product:
392
393
  ```json
393
394
  {
394
395
  "version": 2,
395
- "org": "my-org",
396
+ "orgId": "00000000-0000-0000-0000-000000000000",
396
397
  "inputs": {
397
398
  "cli": {
398
399
  "type": "npm-package",
@@ -414,8 +415,9 @@ existing checkout settings, including GitHub's default merge checkout. Omit
414
415
  `source.artifact` when the workflow uploads one artifact, or select it by name.
415
416
 
416
417
  For automatic checks, connect the Gauge GitHub App with repository access and
417
- Actions read permission. Set `org` and enable the repository and target branches
418
- in **Settings → GitHub**. Waiting for inputs starts no sessions and spends no
418
+ Actions read permission. Run `gauge orgs use <slug> --project` to record the
419
+ organization as `orgId`, and enable the repository and target branches in
420
+ **Settings → GitHub**. Waiting for inputs starts no sessions and spends no
419
421
  session credits.
420
422
  Fork pull requests are disabled by default. Check **Allow fork pull requests** to let
421
423
  workspace members authorize an evaluation from its GitHub check. Authorization
@@ -637,8 +639,8 @@ do not test discovery of the canonical docs. Static verification validates
637
639
  configuration; it does not prove backend support, delivery, or an eval pass.
638
640
 
639
641
  Editor schemas are published at
640
- `https://agents.withgauge.com/schemas/gauge/v2.8.0/gauge.json` and
641
- `https://agents.withgauge.com/schemas/gauge/v2.8.0/case.json`. Associate them in editor
642
+ `https://agents.withgauge.com/schemas/gauge/v2.10.0/gauge.json` and
643
+ `https://agents.withgauge.com/schemas/gauge/v2.10.0/case.json`. Associate them in editor
642
644
  settings; `gauge.json` does not accept a `$schema` field. These release URLs are
643
645
  immutable. Cases default to `gauge-cases/`, or use explicit `cases` paths.
644
646
 
@@ -701,6 +703,96 @@ A prompt with zero scenarios is a valid definition — it simply never comes due
701
703
  Sessions per launch = scenarios × agent/model targets × samples. Omit the
702
704
  run-settings flags on `create` and the org's default roster applies.
703
705
 
706
+ ## Hosted setup and teardown scripts
707
+
708
+ Run `gauge instructions lifecycle` for the complete script API reference and
709
+ the author → preview → launch workflow. This guidance ships with the CLI.
710
+
711
+ Upload JavaScript or TypeScript source on an eval or preference prompt:
712
+
713
+ ```sh
714
+ gauge eval edit <evalId> --hosted --setup-file ./setup.ts --teardown-file ./teardown.ts
715
+ gauge preference edit <promptId> --hosted --setup-file ./setup.ts \
716
+ --setup-timeout 180 --lifecycle-params '{"feature":"checkout"}'
717
+ ```
718
+
719
+ The same file flags work on `create`. The CLI reads UTF-8 files locally and
720
+ uploads their contents; paths are not stored or resolved on the server. Files
721
+ must be nonempty and at most 128 KiB. Each file is one script module; companion
722
+ files are not uploaded. Hooks run in hosted sessions, and are not supported by
723
+ `--local` or Git-authored case definitions.
724
+
725
+ Scripts can use top-level await and the provided session bindings:
726
+
727
+ ```ts
728
+ import { params, state } from "@withgauge/session";
729
+
730
+ console.log("Preparing", params.feature);
731
+ await state.set("prepared", true);
732
+ ```
733
+
734
+ Setup runs before the coding agent. Teardown runs during cleanup, independently
735
+ of the agent's result. Scripts use the session's configured MCP servers and
736
+ Connections. Script authoring itself does not launch a paid session.
737
+
738
+ Each phase defaults to 120 seconds for a new script. Set `--setup-timeout` or
739
+ `--teardown-timeout` to an integer from 1 to 600; these flags can also update an
740
+ existing script's timeout without re-uploading it. Replacing a script preserves
741
+ its timeout unless overridden. `--lifecycle-params` replaces the JSON parameter
742
+ object (maximum 64 KiB); pass `'{}'` to empty it.
743
+
744
+ Hook edits fetch the saved lifecycle configuration and send its updated value,
745
+ preserving the other phase, parameters, and timeouts when omitted. Ordinary
746
+ edits leave lifecycle configuration untouched. To remove scripts:
747
+
748
+ ```sh
749
+ gauge eval edit <evalId> --hosted --clear-setup # keep teardown and params
750
+ gauge preference edit <promptId> --hosted --clear-teardown
751
+ gauge eval edit <evalId> --hosted --clear-lifecycle # remove both and params
752
+ ```
753
+
754
+ Clearing the last script also removes its parameter object. Each new run freezes
755
+ the uploaded configuration; editing it does not change existing sessions.
756
+
757
+ For CLI stubs and redirects, use `gauge run --hosted --cli-rules rules.json`
758
+ with a prompt, saved eval/preference, or case files/spec. Rules apply only to
759
+ that launch; they require no optimization or previous session. They leave
760
+ saved settings and the fixture repository unchanged. Local runs and legacy
761
+ battery specs are unsupported. Read `gauge instructions cli-rules --hosted`
762
+ for a complete v4 stub example, discovery guidance, and matching limits.
763
+
764
+ For a one-off prompt, attach scripts directly without creating a saved eval or
765
+ preference prompt:
766
+
767
+ ```sh
768
+ gauge run --hosted "Build a dashboard" --setup-file ./setup.ts --teardown-file ./teardown.ts \
769
+ --setup-timeout 180 --lifecycle-params '{"feature":"temporary-test"}'
770
+ gauge run --hosted "Build a dashboard" --setup-file ./setup.ts --dry-run
771
+ ```
772
+
773
+ `--dry-run` validates the prompt and hook configuration and shows the configured
774
+ phases and deadlines without displaying source or parameters. It does not execute
775
+ scripts or launch sessions. Only the supplied scripts and parameters apply;
776
+ there is no saved configuration to inherit or update.
777
+
778
+ To override hooks for one launch of a saved measurement, pass the same upload,
779
+ timeout, parameter, or clear flags to `run --eval` or `run --preference`:
780
+
781
+ ```sh
782
+ gauge run --hosted --eval <evalId> --setup-file ./setup.ts --teardown-file ./teardown.ts
783
+ gauge run --hosted --preference <promptId> --scenario <scenarioId> \
784
+ --setup-file ./setup.ts --lifecycle-params '{"feature":"temporary-test"}'
785
+ gauge run --hosted --eval <evalId> --clear-lifecycle
786
+ ```
787
+
788
+ These overrides affect only the requested launch; the saved eval or preference
789
+ prompt is never edited. Unspecified phases, timeouts, and parameters inherit
790
+ the saved values. `--clear-lifecycle` disables both hooks for this launch only.
791
+ Without lifecycle flags, saved measurements use their saved hooks. One-off hook
792
+ flags require hosted execution; they are not supported with `--local`, `--apply`,
793
+ or case files. Saved measurement launches do not support `--dry-run`.
794
+ Launching runs consumes credits normally.
795
+
704
796
  ## Hosted schedules
705
797
 
706
798
  `--cadence none` is "manual": the measurement stops coming due and runs only
@@ -719,11 +811,27 @@ scenario subset leaves the schedule unchanged.
719
811
  ## Issues (hosted)
720
812
 
721
813
  An issue groups the same finding across many sessions. `gauge issues list` shows
722
- every issue with the most sessions first, with its type and product. Friction
723
- shows how badly it hurt agents (blocked, recovered, extra work). Objections come
724
- from preference sessions and show where agents went instead. Filter with
725
- `--type friction|objection`. `gauge issues get <id>` lists the issue's
726
- findings with their runs. `gauge run insight <run>` shows each finding's issue.
814
+ open issues with the most sessions first, with their type, product, and status.
815
+ Friction shows how badly it hurt agents (blocked, recovered, extra work).
816
+ Objections come from preference sessions and show where agents went instead.
817
+ Filter with `--type friction|objection` and `--status open|fixed|muted|all`.
818
+ `gauge issues get <id>` lists the issue's findings with their runs.
819
+ `gauge run insight <run>` shows each finding's issue.
820
+
821
+ Each issue is open, fixed, or muted. A fixed issue reopens when a later run
822
+ shows it again; a muted one never does.
823
+
824
+ ```sh
825
+ gauge issues fix is_1 # done; reopens if agents hit it again
826
+ gauge issues mute is_1 # not relevant; never reopens
827
+ gauge issues reopen is_1 # back to open (also unmutes)
828
+ gauge issues recheck is_1 # preview the past runs it would repeat
829
+ gauge issues recheck is_1 --confirm # rerun them (spends credits); --run <runId>... picks others
830
+ ```
831
+
832
+ `recheck` (alias `verify`) never prompts: without `--confirm` it only prints
833
+ the preview. `gauge issues get` then shows which reruns still show the issue;
834
+ a recheck never closes it, so mark it fixed with `gauge issues fix`.
727
835
 
728
836
  ## Optimizations (hosted)
729
837
 
@@ -760,9 +868,17 @@ gauge optimizations file write op_1 --skill acme --path SKILL.md --from SKILL.md
760
868
  gauge optimizations notes op_1 --from notes.md
761
869
  gauge optimizations launch op_1 --yes
762
870
  gauge optimizations watch op_1
871
+ gauge optimizations launch op_1 --restore-before run_9:140 --yes
872
+ gauge optimizations checkpoints op_1
763
873
  gauge optimizations finish op_1 --from result.json --yes
764
874
  ```
765
875
 
876
+ `launch` restores each rerun from the deepest checkpoint of an earlier rerun
877
+ taken before it saw a changed surface, or starts fresh. `--restore-before
878
+ <rerun>:<seq>` restores from the deepest checkpoint at or before that seq,
879
+ `--checkpoint <id>` from one checkpoint, and `--fresh [sourceRunId...]` starts
880
+ from zero. Launch prints the checkpoint and seq each rerun restored from.
881
+
766
882
  `watch` waits until every rerun finishes and is analyzed, then shows each source
767
883
  finding as resolved or returned, and new findings as introduced. `launches
768
884
  <id> <launchId> -o json` reads one launch again. `result.json` is
@@ -957,13 +1073,25 @@ unless every session completed.
957
1073
  Batch cancellation is persisted before workers are contacted, including during
958
1074
  startup. A pending cancellation returns nonzero; inspect status before retrying.
959
1075
 
960
- After an interruption, `gauge cleanup --local` retries cleanup for recorded
961
- interrupted sessions or sessions with incomplete cleanup in this repository.
1076
+ Session status and `gauge watch` probe the host controller with a one-second
1077
+ deadline. If it cannot be reached, they report `unavailable` and the last known
1078
+ state, without changing the saved outcome. Watch keeps checking and displays
1079
+ terminal results when they arrive. Batch supervisors have no status endpoint;
1080
+ nonterminal batch status is `unavailable` with `lastKnownState` and recorded
1081
+ progress. `run wait` continues waiting for a recorded terminal batch outcome.
1082
+ PIDs are not used to infer interruption because coding-agent commands may run in
1083
+ different process namespaces even when they share the same Gauge workspace.
1084
+
1085
+ `gauge cleanup --local` retries incomplete cleanup for recorded terminal sessions
1086
+ in this repository.
962
1087
  It preserves evidence and recovered work, and makes recovered results visible
963
1088
  in `gauge run list`. It leaves live sessions, other repositories, unrelated
964
1089
  containers, and cached images alone. Recovery checks Gauge's container label
965
1090
  and workspace mount before removing a remaining container. Uncertain worker
966
1091
  ownership is reported rather than signaling a potentially reused PID.
1092
+ If a controller dies abruptly without recording a terminal outcome, status stays
1093
+ unavailable and automatic orphan cleanup is unavailable. Preserve the evidence
1094
+ and runtime files for manual recovery; `run wait` may need to be interrupted.
967
1095
 
968
1096
  Local workers have a 30-minute turn deadline and a 60-second supervisor
969
1097
  response deadline, so losing a supervisor cannot leave an idle worker forever.
@@ -1,2 +1,2 @@
1
- import{runLocal}from"./chunk-NXOOFF5A.js";import"./chunk-QV7MOO3M.js";import"./chunk-MAANSWGU.js";import"./chunk-OIGVDK3F.js";import"./chunk-PSBF4TEK.js";import{randomBytes}from"crypto";import{readFile,rename,rm,writeFile}from"fs/promises";import{dirname,join}from"path";var requestPath=process.argv[2];var directory=dirname(requestPath);var requestLoaded=false;try{const request=JSON.parse(await readFile(requestPath,"utf8"));if(!request||typeof request.batchId!=="string"||typeof request.gaugeDir!=="string"||!request.definition)throw new Error("Invalid batch request");requestLoaded=true;await rm(requestPath);await runLocal(request.definition,[],request.gaugeDir,()=>{},{batchId:request.batchId,credentialSelections:request.credentialSelections,measurement:request.measurement})}catch(error){process.exitCode=1;const detail=requestLoaded?String(error):"Could not read a valid background batch request. Start a new batch.";console.error(detail);const statusPath=join(directory,"status.json");const previous=await readFile(statusPath,"utf8").then(raw=>JSON.parse(raw)).catch(()=>({}));const finishedSessions=previous.finishedSessions??0;const status={...previous,state:"failed",detail,finishedSessions,queuedSessions:0,skippedSessions:Math.max(0,(previous.expectedSessions??0)-finishedSessions),supervisorPid:process.pid};const temporary=`${statusPath}.${randomBytes(6).toString("hex")}.tmp`;await writeFile(temporary,`${JSON.stringify(status,null,2)}
1
+ import{runLocal}from"./chunk-TAFB66SK.js";import"./chunk-PUNARKS2.js";import"./chunk-QV7MOO3M.js";import"./chunk-PMX3NOGH.js";import"./chunk-OIGVDK3F.js";import"./chunk-PSBF4TEK.js";import{randomBytes}from"crypto";import{readFile,rename,rm,writeFile}from"fs/promises";import{dirname,join}from"path";var requestPath=process.argv[2];var directory=dirname(requestPath);var requestLoaded=false;try{const request=JSON.parse(await readFile(requestPath,"utf8"));if(!request||typeof request.batchId!=="string"||typeof request.gaugeDir!=="string"||!request.definition)throw new Error("Invalid batch request");requestLoaded=true;await rm(requestPath);await runLocal(request.definition,[],request.gaugeDir,()=>{},{batchId:request.batchId,credentialSelections:request.credentialSelections,measurement:request.measurement})}catch(error){process.exitCode=1;const detail=requestLoaded?String(error):"Could not read a valid background batch request. Start a new batch.";console.error(detail);const statusPath=join(directory,"status.json");const previous=await readFile(statusPath,"utf8").then(raw=>JSON.parse(raw)).catch(()=>({}));const finishedSessions=previous.finishedSessions??0;const status={...previous,state:"failed",detail,finishedSessions,queuedSessions:0,skippedSessions:Math.max(0,(previous.expectedSessions??0)-finishedSessions),supervisorPid:process.pid};const temporary=`${statusPath}.${randomBytes(6).toString("hex")}.tmp`;await writeFile(temporary,`${JSON.stringify(status,null,2)}
2
2
  `,{mode:384});await rename(temporary,statusPath);await writeFile(join(directory,"error.txt"),detail,{mode:384})}
@@ -1 +1 @@
1
- import{CHAT_API_PREFIX,CHAT_BATCH_SIZE,ChatApiClient,DEFAULT_MAX_ITEMS,addPageOptions,categoryScope,chatPath,chatScope,chunks,createChatApiClient,csv,describeScopes,fetchAll,fetchPages,parsePositive,printPage,resolveChatCategory,resolveChatOrg,resolveTagIds,resolveTopicId,truncate,withCategory}from"./chunk-QWDJLPRW.js";import"./chunk-3I3IT3LG.js";import"./chunk-MAANSWGU.js";import"./chunk-OIGVDK3F.js";import"./chunk-PSBF4TEK.js";export{CHAT_API_PREFIX,CHAT_BATCH_SIZE,ChatApiClient,DEFAULT_MAX_ITEMS,addPageOptions,categoryScope,chatPath,chatScope,chunks,createChatApiClient,csv,describeScopes,fetchAll,fetchPages,parsePositive,printPage,resolveChatCategory,resolveChatOrg,resolveTagIds,resolveTopicId,truncate,withCategory};
1
+ import{CHAT_API_PREFIX,CHAT_BATCH_SIZE,ChatApiClient,DEFAULT_MAX_ITEMS,addPageOptions,categoryScope,chatPath,chatScope,chunks,createChatApiClient,csv,describeScopes,fetchAll,fetchPages,parsePositive,printPage,resolveChatCategory,resolveChatOrg,resolveTagIds,resolveTopicId,truncate,withCategory}from"./chunk-PVTU7NGL.js";import"./chunk-AZKXHO6C.js";import"./chunk-PMX3NOGH.js";import"./chunk-OIGVDK3F.js";import"./chunk-PSBF4TEK.js";export{CHAT_API_PREFIX,CHAT_BATCH_SIZE,ChatApiClient,DEFAULT_MAX_ITEMS,addPageOptions,categoryScope,chatPath,chatScope,chunks,createChatApiClient,csv,describeScopes,fetchAll,fetchPages,parsePositive,printPage,resolveChatCategory,resolveChatOrg,resolveTagIds,resolveTopicId,truncate,withCategory};
@@ -1 +1 @@
1
- import{CliError,createClient,resolveToken}from"./chunk-MAANSWGU.js";var UUID_RE=/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;var isUuid=value=>UUID_RE.test(value);function credentialKind(token=resolveToken()){if(!token)return"none";if(token.startsWith("gauge_cli_"))return"session";if(token.startsWith("gauge_sk_")||!token.startsWith("gauge_"))return"api_key";return"legacy"}async function fetchDirectory(){if(credentialKind()==="legacy")throw new CliError("usage","This Agents token cannot list or select organizations in this version of the CLI.",{hint:"If GAUGE_API_TOKEN is set, unset it first. Then run `gauge auth login` and `gauge orgs`."});const{chatPath,createChatApiClient}=await import("./chatApi-CLMRDLLS.js");const{data}=await createChatApiClient().get(chatPath("orgs"));if(!Array.isArray(data))throw new CliError("internal","Gauge returned an organization list the CLI could not read.",{hint:"Try `gauge orgs` again. If this continues, contact Gauge support."});return data}async function findOrganization(value){const org=(await fetchDirectory()).find(org2=>org2.id===value||org2.slug===value);if(org)return org;const{chatPath,createChatApiClient}=await import("./chatApi-CLMRDLLS.js");return createChatApiClient().get(chatPath("orgs",value))}async function resolveOrgValue(value){return isUuid(value)?{id:value}:findOrganization(value)}function legacySelection(source){const message=source==="config"?"Your saved organization needs to be selected again after this CLI update.":source==="project"?"This project's organization needs to be selected again after this CLI update.":"The organization in this run file needs to be selected again after this CLI update.";const hint=source==="config"?"Run `gauge orgs` to see your organizations, then `gauge orgs use <slug>` to choose one. If you have only one organization, `gauge auth login` updates your saved choice automatically.":source==="project"?"Run `gauge orgs`, then `gauge orgs use <slug> --project` to update gauge.json.":"Run `gauge orgs`, then rerun your command with --org <slug>. Or remove org from the run file to use your saved organization.";throw new CliError("usage",message,{hint})}async function resolveSelection(value,source){if(source!=="flag"&&!isUuid(value))legacySelection(source);return resolveOrgValue(value)}async function keyOrganization(){const{createChatApiClient}=await import("./chatApi-CLMRDLLS.js");const org=(await createChatApiClient().me()).apiKey?.organization;if(!org)throw new CliError("internal","Gauge could not identify which organization this API key belongs to.",{hint:"Check the key in Settings \u2192 API Keys and try again."});return org}async function createdOrganization(agentsSlug){const{orgs}=await createClient().get("/api/v1/me");const id=orgs.find(org=>org.slug===agentsSlug)?.canonicalGaugeOrganizationId;if(!id)throw new CliError("internal","Your workspace was created, but it is not ready to select in the CLI yet.",{hint:"Run `gauge orgs` to check for it, then `gauge orgs use <slug>`. If it is missing, contact Gauge support; you don't need to create it again."});return findOrganization(id)}async function missingAgentsOrg(org){const match=(await fetchDirectory()).find(o=>o.id===org);if(match?.products?.agents!==false)return void 0;return new CliError("not_found",`${match.name} doesn't use Gauge Agents.`,{hint:"Run `gauge orgs` to see which products each organization uses."})}function productsLabel(products){if(!products)return"unknown";return[products.chat?"Chat":void 0,products.agents?"Agents":void 0].filter(Boolean).join(", ")||"-"}export{isUuid,credentialKind,fetchDirectory,findOrganization,resolveOrgValue,legacySelection,resolveSelection,keyOrganization,createdOrganization,missingAgentsOrg,productsLabel};
1
+ import{CliError,createClient,resolveToken}from"./chunk-PMX3NOGH.js";var UUID_RE=/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;var isUuid=value=>UUID_RE.test(value);function credentialKind(token=resolveToken()){if(!token)return"none";if(token.startsWith("gauge_cli_"))return"session";if(token.startsWith("gauge_sk_")||!token.startsWith("gauge_"))return"api_key";return"legacy"}async function fetchDirectory(){if(credentialKind()==="legacy")throw new CliError("usage","This Agents token cannot list or select organizations in this version of the CLI.",{hint:"If GAUGE_API_TOKEN is set, unset it first. Then run `gauge auth login` and `gauge orgs`."});const{chatPath,createChatApiClient}=await import("./chatApi-HF2R3SVR.js");const{data}=await createChatApiClient().get(chatPath("orgs"));if(!Array.isArray(data))throw new CliError("internal","Gauge returned an organization list the CLI could not read.",{hint:"Try `gauge orgs` again. If this continues, contact Gauge support."});return data}async function findOrganization(value){const org=(await fetchDirectory()).find(org2=>org2.id===value||org2.slug===value);if(org)return org;const{chatPath,createChatApiClient}=await import("./chatApi-HF2R3SVR.js");return createChatApiClient().get(chatPath("orgs",value))}async function resolveOrgValue(value){return isUuid(value)?{id:value}:findOrganization(value)}function legacySelection(source){const message=source==="config"?"Your saved organization needs to be selected again after this CLI update.":source==="project"?"This project's organization needs to be selected again after this CLI update.":"The organization in this run file needs to be selected again after this CLI update.";const hint=source==="config"?"Run `gauge orgs` to see your organizations, then `gauge orgs use <slug>` to choose one. If you have only one organization, `gauge auth login` updates your saved choice automatically.":source==="project"?"Run `gauge orgs`, then `gauge orgs use <slug> --project` to update gauge.json.":"Run `gauge orgs`, then rerun your command with --org <slug>. Or remove org from the run file to use your saved organization.";throw new CliError("usage",message,{hint})}async function resolveSelection(value,source){if(source!=="flag"&&!isUuid(value))legacySelection(source);return resolveOrgValue(value)}async function keyOrganization(){const{createChatApiClient}=await import("./chatApi-HF2R3SVR.js");const org=(await createChatApiClient().me()).apiKey?.organization;if(!org)throw new CliError("internal","Gauge could not identify which organization this API key belongs to.",{hint:"Check the key in Settings \u2192 API Keys and try again."});return org}async function createdOrganization(agentsSlug){const{orgs}=await createClient().get("/api/v1/me");const id=orgs.find(org=>org.slug===agentsSlug)?.canonicalGaugeOrganizationId;if(!id)throw new CliError("internal","Your workspace was created, but it is not ready to select in the CLI yet.",{hint:"Run `gauge orgs` to check for it, then `gauge orgs use <slug>`. If it is missing, contact Gauge support; you don't need to create it again."});return findOrganization(id)}async function missingAgentsOrg(org){const match=(await fetchDirectory()).find(o=>o.id===org);if(match?.products?.agents!==false)return void 0;return new CliError("not_found",`${match.name} doesn't use Gauge Agents.`,{hint:"Run `gauge orgs` to see which products each organization uses."})}function productsLabel(products){if(!products)return"unknown";return[products.chat?"Chat":void 0,products.agents?"Agents":void 0].filter(Boolean).join(", ")||"-"}export{isUuid,credentialKind,fetchDirectory,findOrganization,resolveOrgValue,legacySelection,resolveSelection,keyOrganization,createdOrganization,missingAgentsOrg,productsLabel};
@@ -0,0 +1,2 @@
1
+ import{USER_AGENT,configDir,readConfig}from"./chunk-OIGVDK3F.js";import{__export}from"./chunk-PSBF4TEK.js";import{chmodSync,mkdirSync,readFileSync,renameSync,rmSync,writeFileSync}from"fs";import{randomUUID}from"crypto";import{join}from"path";import{setTimeout as sleep}from"timers/promises";function credentialsPath(){return join(configDir(),"credentials")}function readCredentials(){try{const raw=readFileSync(credentialsPath(),"utf8").trim();if(!raw.startsWith("{"))return raw||null;const value=JSON.parse(raw);if(value.version!==1||typeof value.accessToken!=="string"||typeof value.authUrl!=="string"||typeof value.apiUrl!=="string")return null;return value}catch{return null}}function resolveToken(){const fromEnv=process.env.GAUGE_API_TOKEN?.trim();if(fromEnv)return fromEnv;const stored=readCredentials();return typeof stored==="string"?stored:stored?.accessToken??null}function atomicWrite(value){mkdirSync(configDir(),{recursive:true,mode:448});const temporary=`${credentialsPath()}.${randomUUID()}.tmp`;try{writeFileSync(temporary,`${value}
2
+ `,{encoding:"utf8",mode:384,flag:"wx"});chmodSync(temporary,384);renameSync(temporary,credentialsPath())}finally{rmSync(temporary,{force:true})}}function saveToken(token){atomicWrite(token.trim())}function saveCredentials(credentials){atomicWrite(JSON.stringify(credentials))}function clearToken(){rmSync(credentialsPath(),{force:true})}async function withCredentialLock(fn){mkdirSync(configDir(),{recursive:true,mode:448});const path=`${credentialsPath()}.lock`;const deadline=Date.now()+35e3;while(true){try{writeFileSync(path,String(process.pid),{flag:"wx",mode:384});break}catch(error){if(error.code!=="EEXIST")throw error;if(Date.now()>=deadline)throw new Error(`Timed out waiting for credential access. If no Gauge process is running, remove ${path} and retry.`);await sleep(50)}}try{return await fn()}finally{rmSync(path,{force:true})}}import{z}from"zod";var DEFAULT_AUTH_URL="https://app.withgauge.com";function resolveAuthUrl(){return(process.env.GAUGE_AUTH_URL||readConfig().authUrl||DEFAULT_AUTH_URL).replace(/\/+$/,"")}var sharedTokenSchema=z.object({accessToken:z.string().startsWith("gauge_cli_"),refreshToken:z.string().startsWith("gauge_refresh_"),tokenType:z.literal("bearer"),expiresAt:z.iso.datetime({offset:true}),refreshExpiresAt:z.iso.datetime({offset:true})});function storedSharedCredentials(){if(process.env.GAUGE_API_TOKEN?.trim())return null;const stored=readCredentials();return stored&&typeof stored!=="string"?stored:null}function assertTrustedOrigin(baseUrl,credentials){const origin=new URL(baseUrl).origin;if(![credentials.authUrl,credentials.apiUrl].some(value=>new URL(value).origin===origin))throw new Error("Your saved login is for a different Gauge server. Check GAUGE_AUTH_URL and GAUGE_API_URL, then run `gauge auth login` for the server you want to use.")}var RefreshError=class extends Error{constructor(message,unauthorized=false){super(message);this.unauthorized=unauthorized}unauthorized};function uncertainRefresh(){return new RefreshError("Gauge could not renew your login. Run `gauge auth login` to sign in again.",true)}async function refreshCredentials(previous,force=false){return withCredentialLock(async()=>{const current=readCredentials();if(!current||typeof current==="string")throw new Error("Your saved login changed. Run the command again.");if(current.sessionId!==previous.sessionId||current.authUrl!==previous.authUrl||current.apiUrl!==previous.apiUrl)throw new Error("Login changed while this command was running. Retry the command.");if(current.refreshPending)throw uncertainRefresh();if(current.accessToken!==previous.accessToken)return current;if(!current.refreshToken)return current;if(!force&&Date.parse(current.expiresAt??"")>Date.now()+6e4)return current;saveCredentials({...current,refreshPending:true});let response;try{response=await fetch(`${current.authUrl}/api/cli/refresh`,{method:"POST",redirect:"error",signal:AbortSignal.timeout(15e3),headers:{"Content-Type":"application/json",Accept:"application/json"},body:JSON.stringify({refreshToken:current.refreshToken})})}catch{throw uncertainRefresh()}if(response.status===429){saveCredentials(current);throw new RefreshError("Gauge is receiving too many sign-in requests. Wait a moment, then try again.")}if(!response.ok)throw response.status===401?new RefreshError("Your login is no longer valid. Run `gauge auth login` to sign in again.",true):uncertainRefresh();try{const tokens=sharedTokenSchema.parse(await response.json());const next={...current,...tokens};delete next.refreshPending;const latest=readCredentials();if(!latest||typeof latest==="string"||latest.refreshToken!==current.refreshToken)throw new Error("Your saved login changed while Gauge was renewing it. Run the command again.");saveCredentials(next);return next}catch{throw uncertainRefresh()}})}var batteries_exports={};__export(batteries_exports,{BATTERY_AGENTS:()=>BATTERY_AGENTS,BATTERY_CADENCES:()=>BATTERY_CADENCES,BATTERY_MAX_LIMITS:()=>BATTERY_MAX_LIMITS,MAX_SAMPLES_PER_CYCLE:()=>MAX_SAMPLES_PER_CYCLE,batchDetailSchema:()=>batchDetailSchema,batchListQuerySchema:()=>batchListQuerySchema,batchListResponseSchema:()=>batchListResponseSchema,batchRunStatusSchema:()=>batchRunStatusSchema,batchRunSummarySchema:()=>batchRunSummarySchema,batchSummarySchema:()=>batchSummarySchema,batteryAgentSchema:()=>batteryAgentSchema,batteryApplyResponseSchema:()=>batteryApplyResponseSchema,batteryDefaultsSchema:()=>batteryDefaultsSchema,batteryLimitsSchema:()=>batteryLimitsSchema,batteryPlanPromptSchema:()=>batteryPlanPromptSchema,batteryPlanScheduleSchema:()=>batteryPlanScheduleSchema,batteryPlanSchema:()=>batteryPlanSchema,batteryPromptSpecSchema:()=>batteryPromptSpecSchema,batteryScheduleSpecSchema:()=>batteryScheduleSpecSchema,batterySkillRefSchema:()=>batterySkillRefSchema,batterySkillsSchema:()=>batterySkillsSchema,batterySpecSchema:()=>batterySpecSchema});import{z as z3}from"zod";import{z as z2}from"zod";var ERROR_CODES=["unauthorized","forbidden","not_found","invalid_request","insufficient_credits","needs_provider_key","rate_limited","conflict","internal","upgrade_required"];var errorCodeSchema=z2.enum(ERROR_CODES);var upgradeOfferSchema=z2.object({skuId:z2.string(),tierLabel:z2.string(),monthlyAmountCents:z2.number().int(),monthlyCredits:z2.number().int(),billingUrl:z2.string()});var errorEnvelopeSchema=z2.object({error:z2.object({code:errorCodeSchema,message:z2.string(),upgrade:upgradeOfferSchema.optional()})});var listQuerySchema=z2.object({limit:z2.coerce.number().int().min(1).max(200).default(50),cursor:z2.string().optional()});function listResponseSchema(item){return z2.object({items:z2.array(item),nextCursor:z2.string().optional()})}var createdBySchema=z2.object({userId:z2.string().nullable(),email:z2.string().nullable(),name:z2.string().nullable()}).nullable().optional();var BATTERY_AGENTS=["CLAUDE_CODE","CODEX_CLI","CURSOR","PI","OPENCODE","ANTIGRAVITY"];var BATTERY_CADENCES=["NONE"];var batteryAgentSchema=z3.enum(BATTERY_AGENTS);var BATTERY_MAX_LIMITS={maxTurns:30,wallClockS:5400,maxUsd:10};var MAX_SAMPLES_PER_CYCLE=50;var batteryLimitsSchema=z3.object({maxTurns:z3.number().positive().max(BATTERY_MAX_LIMITS.maxTurns).optional(),wallClockS:z3.number().positive().max(BATTERY_MAX_LIMITS.wallClockS).optional(),maxUsd:z3.number().positive().max(BATTERY_MAX_LIMITS.maxUsd).optional()});var batterySkillRefSchema=z3.string().regex(/^[A-Za-z0-9][A-Za-z0-9._-]*@\S+$/,'skills entries must be "name@label" (a bare name is a search, not a reference)');var batterySkillsSchema=z3.array(batterySkillRefSchema);var batteryScheduleSpecSchema=z3.object({repoUrl:z3.string().nullish(),repoRef:z3.string().nullish(),model:z3.string().nullable().optional(),agents:z3.array(batteryAgentSchema).optional(),samplesPerCycle:z3.number().int().min(1).max(MAX_SAMPLES_PER_CYCLE).optional(),cadence:z3.enum(BATTERY_CADENCES).optional(),experiment:z3.string().optional(),limits:batteryLimitsSchema.optional(),skills:batterySkillsSchema.optional()});var batteryDefaultsSchema=z3.object({isBranded:z3.boolean().optional(),topic:z3.string().optional(),tags:z3.array(z3.string()).optional(),model:z3.string().nullable().optional(),agents:z3.array(batteryAgentSchema).optional(),samplesPerCycle:z3.number().int().min(1).max(MAX_SAMPLES_PER_CYCLE).optional(),cadence:z3.enum(BATTERY_CADENCES).optional(),limits:batteryLimitsSchema.optional(),skills:batterySkillsSchema.optional()});var batteryPromptSpecSchema=z3.object({key:z3.string().min(1),text:z3.string().min(1),isBranded:z3.boolean().optional(),topic:z3.string().optional(),tags:z3.array(z3.string()).optional(),experiment:z3.string().optional(),schedules:z3.array(batteryScheduleSpecSchema).optional()});var batterySpecSchema=z3.object({version:z3.literal(1),org:z3.string().optional(),experiment:z3.string().optional(),expand:z3.boolean().optional(),defaults:batteryDefaultsSchema.optional(),prompts:z3.array(batteryPromptSpecSchema).min(1)});var batteryPlanScheduleSchema=z3.object({action:z3.enum(["create","update","none"]),repoUrl:z3.string().nullable(),repoRef:z3.string().nullable(),runs:z3.number().int()});var batteryPlanPromptSchema=z3.object({key:z3.string(),action:z3.enum(["create","update"]),schedules:z3.array(batteryPlanScheduleSchema)});var batteryPlanSchema=z3.object({dryRun:z3.literal(true),org:z3.string(),experiment:z3.string().nullable(),expand:z3.boolean(),prompts:z3.array(batteryPlanPromptSchema),summary:z3.object({promptsToCreate:z3.number().int(),promptsToUpdate:z3.number().int(),schedulesToCreate:z3.number().int(),schedulesToUpdate:z3.number().int(),runsToEnqueue:z3.number().int(),runsByAgent:z3.record(z3.string(),z3.number().int()),estimatedCredits:z3.number().int()})});var batteryApplyResponseSchema=z3.object({batchIds:z3.array(z3.string()),runIds:z3.array(z3.string()),experiment:z3.string().nullable(),blocked:z3.enum(["insufficient_credits","needs_provider_key"]).optional()});var batchRunStatusSchema=z3.enum(["QUEUED","CLAIMED","PROVISIONING","RUNNING","SUCCEEDED","FAILED","TIMED_OUT","CANCELED"]);var batchListQuerySchema=listQuerySchema.extend({promptId:z3.string().optional(),experiment:z3.string().optional()});var batchSummarySchema=z3.object({id:z3.string(),promptId:z3.string(),promptText:z3.string(),experiment:z3.string().nullable(),createdAt:z3.string(),runCounts:z3.record(z3.string(),z3.number().int())});var batchListResponseSchema=listResponseSchema(batchSummarySchema);var batchRunSummarySchema=z3.object({id:z3.string(),agent:z3.string(),model:z3.string(),status:batchRunStatusSchema,createdAt:z3.string(),startedAt:z3.string().nullable(),finishedAt:z3.string().nullable()});var batchDetailSchema=z3.object({id:z3.string(),promptId:z3.string(),promptText:z3.string(),scenario:z3.string(),repoUrl:z3.string().nullable(),repoRef:z3.string().nullable(),experiment:z3.string().nullable(),funding:z3.string(),createdAt:z3.string(),runCounts:z3.record(z3.string(),z3.number().int()),runs:z3.array(batchRunSummarySchema)});var brands_exports={};__export(brands_exports,{BRAND_KINDS:()=>BRAND_KINDS,BRAND_PACKAGE_ECOSYSTEMS:()=>BRAND_PACKAGE_ECOSYSTEMS,brandKindSchema:()=>brandKindSchema,brandListResponseSchema:()=>brandListResponseSchema,brandPackageEcosystemSchema:()=>brandPackageEcosystemSchema,brandPackageInputSchema:()=>brandPackageInputSchema,brandPackageSchema:()=>brandPackageSchema,brandSchema:()=>brandSchema,createBrandBodySchema:()=>createBrandBodySchema,listBrandsQuerySchema:()=>listBrandsQuerySchema,updateBrandBodySchema:()=>updateBrandBodySchema});import{z as z4}from"zod";var BRAND_KINDS=["OWNED","COMPETITOR","OTHER"];var brandKindSchema=z4.enum(BRAND_KINDS);var BRAND_PACKAGE_ECOSYSTEMS=["npm","pypi","cargo","go","rubygems","other"];var brandPackageEcosystemSchema=z4.enum(BRAND_PACKAGE_ECOSYSTEMS);var brandPackageSchema=z4.object({name:z4.string(),ecosystem:z4.string().nullable()});var brandSchema=z4.object({id:z4.string(),name:z4.string(),kind:brandKindSchema,source:z4.string(),aliases:z4.array(z4.string()),websites:z4.array(z4.string()),category:z4.string().nullable(),packages:z4.array(brandPackageSchema),createdAt:z4.string(),updatedAt:z4.string()});var brandPackageInputSchema=z4.object({name:z4.string().min(1),ecosystem:brandPackageEcosystemSchema.nullable().optional()});var createBrandBodySchema=z4.object({name:z4.string().min(1),kind:brandKindSchema,aliases:z4.array(z4.string().min(1)).default([]),websites:z4.array(z4.string().min(1)).default([]),packages:z4.array(brandPackageInputSchema).default([])});var updateBrandBodySchema=z4.object({name:z4.string().min(1).optional(),kind:brandKindSchema.optional(),aliases:z4.array(z4.string().min(1)).optional(),websites:z4.array(z4.string().min(1)).optional(),packages:z4.array(brandPackageInputSchema).optional()});var listBrandsQuerySchema=listQuerySchema.extend({kind:brandKindSchema.optional()});var brandListResponseSchema=listResponseSchema(brandSchema);var feedback_exports={};__export(feedback_exports,{FEEDBACK_KINDS:()=>FEEDBACK_KINDS,createFeedbackBodySchema:()=>createFeedbackBodySchema,createFeedbackResponseSchema:()=>createFeedbackResponseSchema,feedbackKindSchema:()=>feedbackKindSchema});import{z as z5}from"zod";var FEEDBACK_KINDS=["friction","missing","bug","other"];var feedbackKindSchema=z5.enum(FEEDBACK_KINDS);var createFeedbackBodySchema=z5.object({message:z5.string().trim().min(1).max(4e3),kind:feedbackKindSchema.default("other"),command:z5.string().trim().max(500).optional(),org:z5.string().optional()});var createFeedbackResponseSchema=z5.object({id:z5.string()});var keys_exports={};__export(keys_exports,{PROVIDER_TYPES:()=>PROVIDER_TYPES,providerKeyListResponseSchema:()=>providerKeyListResponseSchema,providerKeySchema:()=>providerKeySchema,providerTypeSchema:()=>providerTypeSchema,setProviderKeyBodySchema:()=>setProviderKeyBodySchema,setProviderKeyResponseSchema:()=>setProviderKeyResponseSchema});import{z as z6}from"zod";var PROVIDER_TYPES=["anthropic","openai"];var providerTypeSchema=z6.enum(PROVIDER_TYPES);var setProviderKeyBodySchema=z6.object({key:z6.string().min(1)});var setProviderKeyResponseSchema=z6.object({providerType:providerTypeSchema,last4:z6.string()});var providerKeySchema=z6.object({providerType:providerTypeSchema,last4:z6.string(),createdAt:z6.string(),updatedAt:z6.string()});var providerKeyListResponseSchema=listResponseSchema(providerKeySchema);import{z as z7}from"zod";var DEFAULT_LIFECYCLE_TIMEOUT_SECONDS=120;var MAX_LIFECYCLE_TIMEOUT_SECONDS=600;var MAX_LIFECYCLE_SOURCE_LENGTH=128*1024;var lifecycleScriptSchema=z7.object({source:z7.string().min(1).max(MAX_LIFECYCLE_SOURCE_LENGTH),timeoutSeconds:z7.number().int().min(1).max(MAX_LIFECYCLE_TIMEOUT_SECONDS).default(DEFAULT_LIFECYCLE_TIMEOUT_SECONDS)}).strict();var lifecycleSchema=z7.object({version:z7.literal(1),setup:lifecycleScriptSchema.optional(),teardown:lifecycleScriptSchema.optional(),params:z7.record(z7.string().min(1).max(128),z7.json()).default({})}).strict().refine(value=>value.setup!==void 0||value.teardown!==void 0,{message:"Configure a setup or teardown script"}).refine(value=>new TextEncoder().encode(JSON.stringify(value.params)).byteLength<=64*1024,{path:["params"],message:"Lifecycle parameters must fit within 64 KiB"});var runConfig_exports={};__export(runConfig_exports,{ROSTERABLE_AGENTS:()=>ROSTERABLE_AGENTS,SCHEDULABLE_AGENTS:()=>SCHEDULABLE_AGENTS,agentConfigInputSchema:()=>agentConfigInputSchema,agentConfigSchema:()=>agentConfigSchema,assetRefListSchema:()=>assetRefListSchema,assetRefSchema:()=>assetRefSchema,modelUnits:()=>modelUnits,refAssetName:()=>refAssetName,rosterableAgentSchema:()=>rosterableAgentSchema,runsPerCycle:()=>runsPerCycle,schedulableAgentSchema:()=>schedulableAgentSchema,totalRunsPerCycle:()=>totalRunsPerCycle});import{z as z10}from"zod";import{z as z9}from"zod";var INTERVENTION_KINDS=["BASELINE","ADD_SKILL","REMOVE_SKILL","EDIT_SKILL","REWRITE_DOCS","PACKAGE_VERSION","PACKAGE_CONTENT","CLI_VERSION","CLI_INTERVENTION"];import{z as z8}from"zod";var ANALYSIS_SCHEMA_VERSION=1;var evidenceSequenceSchema=z8.number().int().nonnegative().describe("The event's recorded seq in this session attempt. Never infer it from an array index, line number, or turn.");var evidenceRefSchema=z8.discriminatedUnion("kind",[z8.object({kind:z8.literal("trace"),seq:evidenceSequenceSchema}).strict(),z8.object({kind:z8.literal("diff"),path:z8.string().min(1)}).strict()]);var INSTALL_PHASES=["NONE","ATTEMPTED","CONFIGURED","EXERCISED"];var sessionProductSchema=z8.object({name:z8.string(),mentioned:z8.boolean(),considered:z8.boolean(),recommended:z8.boolean(),chosen:z8.boolean(),rejected:z8.boolean(),abandoned:z8.boolean(),installPhase:z8.enum(INSTALL_PHASES),rank:z8.number().int().nullable(),source:z8.enum(["BRIEF","PERSONA","PRIOR","SEARCH","PAGE","REPO","UNKNOWN"]),reason:z8.string(),categories:z8.array(z8.string()),evidence:z8.record(z8.string(),z8.array(evidenceRefSchema))});var sessionObservationSchema=z8.object({id:z8.string(),kind:z8.enum(["FRICTION","OBJECTION","OPPORTUNITY"]),label:z8.string(),detail:z8.string(),subject:z8.string(),basis:z8.enum(["OBSERVED","AGENT_CLAIM","INFERRED"]),effect:z8.enum(["BLOCKED","RECOVERED","EXTRA_WORK","SELECTION_LOSS","UNKNOWN"]),cause:z8.enum(["PRODUCT","CONTENT","ACCESS","ENVIRONMENT","AGENT","UNKNOWN"]),tags:z8.array(z8.string()),evidence:z8.array(evidenceRefSchema),issueId:z8.string().nullable().optional()});var sessionAnalysisSchema=z8.object({schemaVersion:z8.literal(ANALYSIS_SCHEMA_VERSION),instructionsVersion:z8.string().min(1),id:z8.string(),runId:z8.string(),attempt:z8.number().int(),createdAt:z8.string(),origin:z8.enum(["MODEL","LEGACY"]),model:z8.string().nullable(),assessability:z8.enum(["ASSESSED","PARTIAL","UNASSESSABLE"]),limitation:z8.string().nullable(),selection:z8.enum(["MEASURED","UNASSESSABLE","NOT_MEASURED"]),directed:z8.boolean(),products:z8.array(sessionProductSchema),observations:z8.array(sessionObservationSchema)});var artifactPathSchema=z8.string().min(1).refine(value=>!value.startsWith("/")&&!value.includes("\\")&&!value.split("/").some(part=>part===".."||part===""),"Evidence paths must be relative paths inside the session artifacts");var portableEvidenceRefSchema=z8.discriminatedUnion("kind",[z8.object({kind:z8.literal("trace"),seq:evidenceSequenceSchema}).strict(),z8.object({kind:z8.literal("diff"),path:artifactPathSchema}).strict(),z8.object({kind:z8.literal("artifact"),artifact:artifactPathSchema.describe("Path relative to the session attempt directory, for example session/events.ndjson."),attempt:z8.number().int().positive().optional().describe("Must match the analysis attempt; defaults to that attempt."),line:z8.number().int().positive().optional().describe("One-based line number in the original artifact, before any filtering."),endLine:z8.number().int().positive().optional().describe("Inclusive last line of the evidence range."),seq:evidenceSequenceSchema.optional()}).strict().superRefine((ref,ctx)=>{if(ref.line===void 0&&ref.seq===void 0)ctx.addIssue({code:"custom",message:"Artifact evidence needs a line or seq"});if(ref.endLine!==void 0&&(ref.line===void 0||ref.endLine<ref.line))ctx.addIssue({code:"custom",path:["endLine"],message:"endLine requires line and must be at least line"})})]);var findingSubmissionSchema=sessionObservationSchema.omit({id:true,issueId:true}).extend({label:z8.string().trim().min(1).max(200),detail:z8.string().trim().min(1).max(1e4),subject:z8.string().trim().min(1).max(200),tags:z8.array(z8.string().trim().min(1).max(64)).max(32).default([]),evidence:z8.array(portableEvidenceRefSchema).min(1).max(100)}).strict();var criterionAnalysisSubmissionSchema=z8.object({criterionId:z8.string().min(1),outcome:z8.enum(["PASS","FAIL","UNASSESSABLE"]),label:z8.string().trim().min(1).max(1e4),evidence:z8.array(portableEvidenceRefSchema).max(100).default([])}).strict().superRefine((result,ctx)=>{if(result.outcome!=="UNASSESSABLE"&&result.evidence.length===0)ctx.addIssue({code:"custom",path:["evidence"],message:"A criterion verdict needs evidence"})});var productSubmissionSchema=sessionProductSchema.extend({name:z8.string().trim().min(1).max(200),evidence:z8.record(z8.string(),z8.array(portableEvidenceRefSchema))}).strict().superRefine((product,ctx)=>{if((product.chosen||product.rejected||product.recommended)&&!product.considered)ctx.addIssue({code:"custom",path:["considered"],message:"A chosen, rejected, or recommended product was considered"});if(product.considered&&!product.mentioned)ctx.addIssue({code:"custom",path:["mentioned"],message:"A considered product was mentioned"});if(!Object.values(product.evidence).some(refs=>refs.length>0))ctx.addIssue({code:"custom",path:["evidence"],message:"A product judgment needs evidence"})});var analysisSubmissionSchema=z8.object({schemaVersion:z8.literal(ANALYSIS_SCHEMA_VERSION),attempt:z8.number().int().positive().default(1),instructionsVersion:z8.string().trim().min(1),analyst:z8.object({name:z8.string().trim().min(1),model:z8.string().trim().min(1).optional()}).strict(),assessability:sessionAnalysisSchema.shape.assessability,limitation:z8.string().trim().min(1).nullable().default(null),selection:sessionAnalysisSchema.shape.selection.default("NOT_MEASURED"),directed:z8.boolean().default(false),findings:z8.array(findingSubmissionSchema).max(1e3).default([]),products:z8.array(productSubmissionSchema).max(1e3).default([]),criteria:z8.array(criterionAnalysisSubmissionSchema).max(1e3).default([])}).strict().superRefine((analysis,ctx)=>{for(const field of["products","criteria"]){const keys=field==="products"?analysis.products.map(product=>product.name.toLowerCase()):analysis.criteria.map(criterion=>criterion.criterionId);if(new Set(keys).size!==keys.length)ctx.addIssue({code:"custom",path:[field],message:`Duplicate ${field} are not allowed`})}if(analysis.assessability!=="ASSESSED"&&analysis.limitation===null)ctx.addIssue({code:"custom",path:["limitation"],message:"Partial or unassessable analysis needs a limitation"})});var RUN_STATUSES=["QUEUED","CLAIMED","PROVISIONING","RUNNING","SUCCEEDED","FAILED","TIMED_OUT","CANCELED"];var runStatusSchema=z9.enum(RUN_STATUSES);var AGENTS=["CLAUDE_CODE","CODEX_CLI","CURSOR","PI","OPENCODE","ANTIGRAVITY"];var agentSchema=z9.enum(AGENTS);var OBSERVED_PROVIDER_SOURCES=["AGENT_STREAM","GATEWAY_RESPONSE","GATEWAY_AUDIT","CANARY"];var observedProviderSourceSchema=z9.enum(OBSERVED_PROVIDER_SOURCES);var selectedProviderSchema=z9.object({slug:z9.string(),displayName:z9.string()});var observedProviderSchema=z9.object({slug:z9.string(),source:observedProviderSourceSchema});var RUN_TRIGGER_SOURCES=["UNKNOWN","UI","API","CADENCE","STAFF","OPERATOR","GITHUB"];var runTriggerSourceSchema=z9.enum(RUN_TRIGGER_SOURCES);var runTriggeredBySchema=z9.object({source:runTriggerSourceSchema,userId:z9.string().nullable(),email:z9.string().nullable()});var runOptimizationTrialSchema=z9.object({optimizationId:z9.string(),trialId:z9.string(),key:z9.string(),title:z9.string(),kind:z9.enum(INTERVENTION_KINDS)});var runCreditsChargedSchema=z9.number().int().nullable();var runStatusFilterSchema=z9.string().transform(raw=>raw.split(",").map(s=>s.trim().toUpperCase()).filter(Boolean)).pipe(z9.array(runStatusSchema).min(1));var runListQuerySchema=listQuerySchema.extend({status:runStatusFilterSchema.optional(),batch:z9.string().optional(),prompt:z9.string().optional(),experiment:z9.string().optional(),evalSet:z9.string().optional(),since:z9.string().optional()});var runListItemSchema=z9.object({id:z9.string(),status:runStatusSchema,agent:agentSchema,model:z9.string(),resolvedModel:z9.string().nullable().optional(),modelDisplayName:z9.string().nullable().optional(),selectedProvider:selectedProviderSchema.nullable().optional(),observedProvider:observedProviderSchema.nullable().optional(),promptId:z9.string(),promptSnippet:z9.string(),batchId:z9.string(),experiment:z9.string().nullable(),evalSetId:z9.string().nullable(),evalRevision:z9.string().optional(),optimizationTrial:runOptimizationTrialSchema.nullable().optional(),turns:z9.number().int().nullable(),usdCost:z9.number().nullable(),creditsCharged:runCreditsChargedSchema.optional(),triggeredBy:runTriggeredBySchema.optional(),durationMs:z9.number().int().nullable(),exitReason:z9.string().nullable(),createdAt:z9.string(),startedAt:z9.string().nullable(),finishedAt:z9.string().nullable(),parentRunId:z9.string().nullable(),fetchForkPlanId:z9.string().nullable()});var runListResponseSchema=listResponseSchema(runListItemSchema);var runSkillSchema=z9.discriminatedUnion("source",[z9.object({source:z9.literal("saved"),skillId:z9.string(),name:z9.string(),label:z9.string()}),z9.object({source:z9.literal("input"),name:z9.string(),commit:z9.string().nullable(),pullNumber:z9.number().int().nullable()})]);var runDetailSchema=runListItemSchema.omit({promptSnippet:true}).extend({promptText:z9.string(),attempt:z9.number().int(),cancelRequested:z9.boolean(),failureReason:z9.string().nullable(),repoUrl:z9.string().nullable(),repoRef:z9.string().nullable(),scenario:z9.string(),funding:z9.string(),usage:z9.unknown().nullable(),hasDiff:z9.boolean(),claimedAt:z9.string().nullable(),criterionResults:z9.array(z9.object({criterionId:z9.string().nullable(),name:z9.string(),passed:z9.boolean().nullable(),reasoning:z9.string().nullable()})),skills:z9.array(runSkillSchema).optional()});var cancelRunResponseSchema=z9.object({id:z9.string(),status:runStatusSchema,cancelRequested:z9.boolean(),note:z9.string().optional()});var regradeRunResponseSchema=z9.object({runId:z9.string(),evalSetId:z9.string().nullable(),criteria:z9.number().int()});var RUN_INSIGHT_STATUSES=["PENDING","RUNNING","COMPLETE","FAILED","SKIPPED"];var runInsightStatusSchema=z9.enum(RUN_INSIGHT_STATUSES);var insightPassSchema=z9.object({status:runInsightStatusSchema,model:z9.string().nullable(),inputTokens:z9.number().int().nullable(),outputTokens:z9.number().int().nullable(),usdCost:z9.number().nullable(),error:z9.string().nullable()});var runDecisionSchema=z9.object({index:z9.number().int(),category:z9.string(),categoryRaw:z9.string().nullable(),chosenName:z9.string(),chosenEcosystem:z9.string().nullable(),chosenPackage:z9.string().nullable(),reversed:z9.boolean(),detail:z9.unknown()});var RUN_INSIGHT_PASS_KINDS=["ANALYSIS","CLI_DISCOVERY","LEVER","EXPERIMENT_DELTA"];var runInsightPassKindSchema=z9.enum(RUN_INSIGHT_PASS_KINDS);var insightPipelinePassSchema=insightPassSchema.extend({kind:runInsightPassKindSchema});var runInsightResponseSchema=z9.object({runId:z9.string(),decision:insightPassSchema,passes:z9.array(insightPipelinePassSchema),decisions:z9.array(runDecisionSchema),experimentDelta:z9.unknown().nullable(),visibilityVerdict:z9.unknown().nullable(),analysis:sessionAnalysisSchema.nullable()});var runEventSchema=z9.looseObject({run_id:z9.string(),seq:z9.number(),turn:z9.number(),ts:z9.string(),type:z9.string()});var runCompareSideSchema=z9.object({runRequest:z9.string().min(1).optional(),batch:z9.array(z9.string().min(1)).min(1).max(100).optional(),evalSet:z9.string().min(1).optional(),evalRevision:z9.string().min(1).optional(),trial:z9.string().min(1).optional(),experiment:z9.string().min(1).optional(),agent:z9.array(agentSchema).min(1).optional(),model:z9.array(z9.string()).min(1).optional(),since:z9.string().optional(),until:z9.string().optional()}).strict().refine(side=>side.runRequest!==void 0||side.batch!==void 0||side.evalSet!==void 0||side.experiment!==void 0||side.trial!==void 0,"Select runs with runRequest, batch, evalSet, experiment, or trial");var runCompareBodySchema=z9.object({baseline:runCompareSideSchema,candidate:runCompareSideSchema}).strict();var runCompareStatsSchema=z9.object({runs:z9.number().int(),finished:z9.number().int(),succeeded:z9.number().int(),judged:z9.number().int(),passed:z9.number().int(),passRate:z9.number().nullable(),medianTurns:z9.number().nullable(),medianUsdCost:z9.number().nullable(),medianDurationMs:z9.number().nullable(),criteria:z9.array(z9.object({name:z9.string(),judged:z9.number().int(),passed:z9.number().int(),passRate:z9.number().nullable()}))});var runCompareDeltaSchema=z9.object({passRate:z9.number().nullable(),medianTurns:z9.number().nullable(),medianUsdCost:z9.number().nullable(),medianDurationMs:z9.number().nullable(),criteria:z9.array(z9.object({name:z9.string(),passRate:z9.number().nullable()}))});var runCompareRowSchema=z9.object({baseline:runCompareStatsSchema,candidate:runCompareStatsSchema,delta:runCompareDeltaSchema});var runCompareMixedRevisionSchema=z9.object({evalSetId:z9.string().nullable(),promptId:z9.string().nullable(),revisions:z9.array(z9.string())});var runCompareTrialSchema=runOptimizationTrialSchema.extend({runs:z9.number().int()});var runCompareResponseSchema=z9.object({overall:runCompareRowSchema,targets:z9.array(runCompareRowSchema.extend({agent:agentSchema,model:z9.string()})),sides:z9.object({baseline:z9.object({evalRevisions:z9.array(z9.string()),mixedRevisions:z9.array(runCompareMixedRevisionSchema).optional(),truncated:z9.boolean(),trials:z9.array(runCompareTrialSchema).optional()}),candidate:z9.object({evalRevisions:z9.array(z9.string()),mixedRevisions:z9.array(runCompareMixedRevisionSchema).optional(),truncated:z9.boolean(),trials:z9.array(runCompareTrialSchema).optional()})})});var SCHEDULABLE_AGENTS=["CLAUDE_CODE","CODEX_CLI","PI","OPENCODE"];var schedulableAgentSchema=z10.enum(SCHEDULABLE_AGENTS);var ROSTERABLE_AGENTS=[...SCHEDULABLE_AGENTS,"ANTIGRAVITY"];var rosterableAgentSchema=z10.enum(ROSTERABLE_AGENTS);var agentConfigSchema=z10.object({agent:agentSchema,models:z10.array(z10.string().min(1))});var agentConfigInputSchema=z10.object({agent:rosterableAgentSchema,models:z10.array(z10.string().min(1)).default([])});var assetRefSchema=z10.string().max(320).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*@[^\s,]+$/,'asset references must be "name@label"');function refAssetName(ref){const at=ref.indexOf("@");return at<0?ref:ref.slice(0,at)}var assetRefListSchema=z10.array(assetRefSchema).superRefine((refs,ctx)=>{const names=new Set;for(const ref of refs){const name=refAssetName(ref);if(names.has(name)){ctx.addIssue({code:"custom",message:`"${ref}" names an asset already referenced \u2014 one version per asset`})}names.add(name)}});function modelUnits(agents){return agents.reduce((n,a)=>n+Math.max(1,a.models.length),0)}function runsPerCycle(owner,samplesPerCycle){return modelUnits(owner.agents)*samplesPerCycle}function totalRunsPerCycle(owners,samplesPerCycle){return owners.reduce((n,o)=>n+runsPerCycle(o,samplesPerCycle),0)}var DEFAULT_API_URL="https://agents.withgauge.com";function exitCodeFor(code){switch(code){case"usage":case"invalid_request":return 2;case"insufficient_credits":case"needs_provider_key":return 3;default:return 1}}var CliError=class extends Error{code;exitCode;hint;docs;needsAccount;apiCode;details;constructor(code,message,options={}){super(message);this.name="CliError";this.code=code;this.exitCode=exitCodeFor(code);this.hint=options.hint;this.docs=options.docs;this.needsAccount=options.needsAccount??false;this.apiCode=options.apiCode;this.details=options.details}};function resolveBaseUrl(){return process.env.GAUGE_API_URL||readConfig().apiUrl||DEFAULT_API_URL}var ApiClient=class{baseUrl;token;shared;authOptional;constructor(options={}){this.baseUrl=(options.baseUrl??resolveBaseUrl()).replace(/\/+$/,"");this.token=options.token!==void 0?options.token:resolveToken();this.authOptional=options.authOptional??false;this.shared=options.token===void 0?storedSharedCredentials():null;if(this.shared)assertTrustedOrigin(this.baseUrl,this.shared)}get signedIn(){return this.token!==null}async get(path,query,signal){return this.request("GET",path,{query,signal})}async post(path,body,query){return this.request("POST",path,{body,query})}async patch(path,body,query){return this.request("PATCH",path,{body,query})}async put(path,body,query){return this.request("PUT",path,{body,query})}async delete(path,query,body){return this.request("DELETE",path,{body,query})}async sse(path,onEvent,options={}){const res=await this.authenticatedFetch(this.url(path,options.query),{method:"GET",headers:this.headers({Accept:"text/event-stream"}),signal:options.signal});if(!res.ok)throw await this.toError(res);if(!res.body){throw new CliError("internal","Event stream had no response body")}const reader=res.body.getReader();const decoder=new TextDecoder;let buffer="";try{while(true){const{done,value}=await reader.read();if(done)break;buffer+=decoder.decode(value,{stream:true});let boundary=buffer.indexOf("\n\n");while(boundary!==-1){const raw=buffer.slice(0,boundary);const event=parseSseFrame(raw);buffer=buffer.slice(boundary+2);if(event)onEvent(event);else if(raw.trimStart().startsWith(":"))options.onComment?.();boundary=buffer.indexOf("\n\n")}}}catch(error){if(error instanceof Error&&error.name==="AbortError")return;throw new CliError("network",`Event stream failed: ${messageOf(error)}`)}}url(path,query){const url=new URL(`${this.baseUrl}${path}`);for(const[key,value]of Object.entries(query??{})){if(Array.isArray(value))for(const item of value)url.searchParams.append(key,item);else if(value!==void 0)url.searchParams.set(key,String(value))}return url}headers(extra){if(!this.token&&!this.authOptional){throw new CliError("unauthorized","Not logged in. Run `gauge auth login` or set GAUGE_API_TOKEN.",{needsAccount:true})}return{...this.token?{Authorization:`Bearer ${this.token}`}:{},"User-Agent":USER_AGENT,Accept:"application/json",...extra}}async authenticatedFetch(url,init){let renewalFailed=false;if(this.shared?.refreshToken){try{const next=await refreshCredentials(this.shared);assertTrustedOrigin(this.baseUrl,next);this.shared=next;this.token=this.shared.accessToken}catch(error){if(error instanceof RefreshError&&error.unauthorized)throw new CliError("unauthorized",messageOf(error));if(!(error instanceof RefreshError)||!(Date.parse(this.shared.expiresAt??"")>Date.now()))throw new CliError("network",messageOf(error));renewalFailed=true}}const send=()=>this.fetch(url,{...init,redirect:"error",headers:{...init.headers,...this.token?{Authorization:`Bearer ${this.token}`}:{}}});const response=await send();if(response.status!==401||!this.shared?.refreshToken||renewalFailed)return response;await response.body?.cancel();try{const next=await refreshCredentials(this.shared,true);assertTrustedOrigin(this.baseUrl,next);this.shared=next;this.token=this.shared.accessToken}catch(error){throw new CliError(error instanceof RefreshError&&error.unauthorized?"unauthorized":"network",messageOf(error))}return send()}async fetch(url,init){try{return await fetch(url,init)}catch(error){if(error instanceof Error&&error.name==="AbortError")throw error;throw new CliError("network",`Request to ${url.host} failed: ${messageOf(error)}`)}}async request(method,path,options={}){const headers=this.headers(options.body===void 0?void 0:{"Content-Type":"application/json"});const res=await this.authenticatedFetch(this.url(path,options.query),{method,headers,body:options.body===void 0?void 0:JSON.stringify(options.body),signal:options.signal});if(!res.ok)throw await this.toError(res);if(res.status===204)return void 0;const text=await res.text();if(!text)return void 0;const contentType=res.headers.get("content-type")??"";if(contentType.includes("application/json")){return JSON.parse(text)}return text}async toError(res){const wait=res.status===429?retryAfterSeconds(res):void 0;const hint=wait===void 0?void 0:`Try again in ${wait} s.`;try{const parsed=errorEnvelopeSchema.safeParse(await res.clone().json());if(parsed.success){const{code,message}=parsed.data.error;if(code==="not_found"&&message.startsWith("Organization not found")){const explained=await explainMissingOrg(res.url);if(explained)return explained}return new CliError(code,message,{hint})}}catch{}const what=res.status===429?"Rate limited by the Gauge API":res.status>=500?"Gauge API server error":"API request failed";return new CliError(codeForStatus(res.status),`${what}: HTTP ${res.status} ${res.statusText}`.trim(),{hint})}};async function explainMissingOrg(url){const match=url&&/\/api\/v1\/orgs\/([^/?#]+)/.exec(new URL(url).pathname);if(!match)return void 0;try{const{missingAgentsOrg}=await import("./orgDirectory-QCOOVF65.js");return await missingAgentsOrg(decodeURIComponent(match[1]))}catch{return void 0}}function createClient(options){return new ApiClient(options)}function retryAfterSeconds(res){const value=res.headers.get("retry-after");if(!value)return void 0;const seconds=Number(value);const at=Date.parse(value);if(Number.isFinite(seconds))return Math.max(0,Math.ceil(seconds));if(Number.isNaN(at))return void 0;return Math.max(0,Math.ceil((at-Date.now())/1e3))}function codeForStatus(status){switch(status){case 400:return"invalid_request";case 401:return"unauthorized";case 402:return"insufficient_credits";case 403:return"forbidden";case 404:return"not_found";case 409:return"conflict";case 429:return"rate_limited";default:return"internal"}}function parseSseFrame(frame){let eventName;const dataLines=[];for(const line of frame.split("\n")){if(line.startsWith(":"))continue;if(line.startsWith("event:")){eventName=line.slice("event:".length).trim()}else if(line.startsWith("data:")){dataLines.push(line.slice("data:".length).replace(/^ /,""))}}if(dataLines.length===0)return null;return{event:eventName,data:dataLines.join("\n")}}function messageOf(error){if(error instanceof Error){const cause=error.cause instanceof Error?`: ${error.cause.message}`:"";return`${error.message}${cause}`}return String(error)}export{errorEnvelopeSchema,listResponseSchema,createdBySchema,batteries_exports,brands_exports,feedback_exports,keys_exports,DEFAULT_LIFECYCLE_TIMEOUT_SECONDS,MAX_LIFECYCLE_TIMEOUT_SECONDS,MAX_LIFECYCLE_SOURCE_LENGTH,lifecycleSchema,ANALYSIS_SCHEMA_VERSION,analysisSubmissionSchema,agentSchema,runTriggeredBySchema,runCreditsChargedSchema,runEventSchema,agentConfigSchema,agentConfigInputSchema,assetRefListSchema,runConfig_exports,credentialsPath,readCredentials,resolveToken,saveToken,saveCredentials,clearToken,withCredentialLock,resolveAuthUrl,sharedTokenSchema,storedSharedCredentials,exitCodeFor,CliError,resolveBaseUrl,ApiClient,createClient,retryAfterSeconds,codeForStatus};
@@ -0,0 +1,64 @@
1
+ import{DockerCli,PI_AGENT_DIR,agentEnv,cleanupGateway,harnessCommand,prepareScript,preserveWorkspace,shellQuote,splitModel,validateGateway}from"./chunk-QV7MOO3M.js";import{CliError}from"./chunk-PMX3NOGH.js";import{randomUUID}from"crypto";import{chmodSync,existsSync,mkdirSync,readdirSync,readFileSync,statSync}from"fs";import{createRequire}from"module";import{join}from"path";var LOCAL_DATABASE_VERSION=1;var schema=`
2
+ CREATE TABLE measurements (
3
+ id TEXT PRIMARY KEY, kind TEXT NOT NULL CHECK(kind IN ('eval','preference')),
4
+ revision INTEGER NOT NULL, definition TEXT NOT NULL,
5
+ created_at TEXT NOT NULL, updated_at TEXT NOT NULL, deleted_at TEXT
6
+ );
7
+ CREATE TABLE measurement_revisions (
8
+ measurement_id TEXT NOT NULL REFERENCES measurements(id), revision INTEGER NOT NULL,
9
+ definition TEXT NOT NULL, created_at TEXT NOT NULL,
10
+ PRIMARY KEY(measurement_id,revision)
11
+ );
12
+ CREATE TABLE launches (
13
+ id TEXT PRIMARY KEY, measurement_id TEXT, measurement_revision INTEGER,
14
+ configuration TEXT NOT NULL, provenance TEXT NOT NULL, created_at TEXT NOT NULL
15
+ );
16
+ CREATE TABLE sessions (
17
+ id TEXT PRIMARY KEY, batch_id TEXT NOT NULL, launch_id TEXT,
18
+ measurement_id TEXT, measurement_kind TEXT, measurement_revision INTEGER,
19
+ case_path TEXT, agent TEXT NOT NULL, model TEXT NOT NULL, attempt INTEGER NOT NULL,
20
+ outcome TEXT NOT NULL, ended_by TEXT, turns INTEGER, created_at TEXT NOT NULL,
21
+ ended_at TEXT, duration_ms REAL, input_tokens INTEGER, output_tokens INTEGER,
22
+ configuration TEXT NOT NULL, provenance TEXT NOT NULL, current_analysis_id TEXT
23
+ );
24
+ CREATE INDEX sessions_measurement ON sessions(measurement_id,created_at);
25
+ CREATE INDEX sessions_batch ON sessions(batch_id);
26
+ CREATE TABLE session_analyses (
27
+ id TEXT PRIMARY KEY, run_id TEXT NOT NULL REFERENCES sessions(id), attempt INTEGER NOT NULL,
28
+ revision INTEGER NOT NULL, schema_version INTEGER NOT NULL, instructions_version TEXT NOT NULL,
29
+ evidence_digest TEXT NOT NULL, payload TEXT NOT NULL, created_at TEXT NOT NULL,
30
+ UNIQUE(run_id,revision)
31
+ );
32
+ CREATE TABLE session_findings (
33
+ id TEXT PRIMARY KEY, analysis_id TEXT NOT NULL REFERENCES session_analyses(id),
34
+ kind TEXT NOT NULL, subject TEXT NOT NULL, label TEXT NOT NULL, detail TEXT NOT NULL,
35
+ basis TEXT NOT NULL, effect TEXT NOT NULL, cause TEXT NOT NULL, tags TEXT NOT NULL, evidence TEXT NOT NULL
36
+ );
37
+ CREATE INDEX findings_analysis ON session_findings(analysis_id);
38
+ CREATE TABLE session_products (
39
+ analysis_id TEXT NOT NULL REFERENCES session_analyses(id), position INTEGER NOT NULL,
40
+ name TEXT NOT NULL, payload TEXT NOT NULL, PRIMARY KEY(analysis_id,position)
41
+ );
42
+ CREATE TABLE criterion_results (
43
+ analysis_id TEXT NOT NULL REFERENCES session_analyses(id), criterion_id TEXT NOT NULL,
44
+ outcome TEXT NOT NULL, label TEXT NOT NULL, evidence TEXT NOT NULL,
45
+ PRIMARY KEY(analysis_id,criterion_id)
46
+ );
47
+ PRAGMA user_version = 1;
48
+ `;var json=value=>JSON.stringify(value);var object=value=>value!==null&&typeof value==="object"&&!Array.isArray(value)?value:{};var parse=value=>JSON.parse(String(value));var LocalStore=class{constructor(gaugeDir,db){this.gaugeDir=gaugeDir;this.db=db}gaugeDir;db;close(){this.db.close()}transaction(fn){this.db.exec("BEGIN IMMEDIATE");try{const value=fn();this.db.exec("COMMIT");return value}catch(error){this.db.exec("ROLLBACK");throw error}}createMeasurement(kind,definition){const normalized=normalizeDefinition(definition);const id=`${kind==="eval"?"ev":"pr"}_${randomUUID()}`;const now=new Date().toISOString();this.transaction(()=>{this.db.prepare("INSERT INTO measurements VALUES (?,?,?,?,?,?,NULL)").run(id,kind,1,json(normalized),now,now);this.db.prepare("INSERT INTO measurement_revisions VALUES (?,?,?,?)").run(id,1,json(normalized),now)});return this.getMeasurement(id)}getMeasurement(id,kind){const row=this.db.prepare("SELECT * FROM measurements WHERE id = ? AND deleted_at IS NULL").get(id);return row&&(!kind||row.kind===kind)?measurement(row):void 0}requireMeasurement(id,kind){const value=this.getMeasurement(id,kind);if(!value)throw new CliError("usage",`Local ${kind??"measurement"} ${id} was not found in this workspace.`,{hint:"List saved measurements with gauge eval list --local or gauge preference list --local."});return value}listMeasurements(kind){const rows=kind?this.db.prepare("SELECT * FROM measurements WHERE kind = ? AND deleted_at IS NULL ORDER BY created_at DESC,id").all(kind):this.db.prepare("SELECT * FROM measurements WHERE deleted_at IS NULL ORDER BY created_at DESC,id").all();return rows.map(measurement)}getMeasurementRevision(id,revision){const row=this.db.prepare("SELECT definition FROM measurement_revisions WHERE measurement_id = ? AND revision = ?").get(id,revision);return row?parse(row.definition):void 0}updateMeasurement(id,patch){this.transaction(()=>{const previous=this.requireMeasurement(id);const original=this.getMeasurementRevision(id,previous.revision);const definition=normalizeDefinition({...original,...patch});const revision=previous.revision+1;const now=new Date().toISOString();this.db.prepare("INSERT INTO measurement_revisions VALUES (?,?,?,?)").run(id,revision,json(definition),now);this.db.prepare("UPDATE measurements SET definition = ?, revision = ?, updated_at = ? WHERE id = ?").run(json(definition),revision,now,id)});return this.requireMeasurement(id)}deleteMeasurement(id){this.requireMeasurement(id);this.db.prepare("UPDATE measurements SET deleted_at = ? WHERE id = ?").run(new Date().toISOString(),id)}recordLaunch(input){const value={...input,id:input.id??`l_${randomUUID()}`,createdAt:input.createdAt??new Date().toISOString(),measurementId:input.measurementId??null,measurementRevision:input.measurementRevision??null};if(value.measurementId&&(value.measurementRevision===null||!this.getMeasurementRevision(value.measurementId,value.measurementRevision))){throw new CliError("usage","Launch must reference an existing measurement revision.")}this.db.prepare("INSERT INTO launches VALUES (?,?,?,?,?,?)").run(value.id,value.measurementId,value.measurementRevision,json(value.configuration),json(value.provenance),value.createdAt);return value}getLaunch(id){const row=this.db.prepare("SELECT * FROM launches WHERE id = ?").get(id);return row?{id:String(row.id),measurementId:row.measurement_id,measurementRevision:row.measurement_revision,configuration:parse(row.configuration),provenance:parse(row.provenance),createdAt:String(row.created_at)}:void 0}upsertSession(input){if(!Number.isInteger(input.attempt)||input.attempt<1)throw new CliError("usage","Session attempt must be a positive integer.");this.db.prepare(`INSERT INTO sessions (
49
+ id,batch_id,launch_id,measurement_id,measurement_kind,measurement_revision,case_path,agent,model,attempt,outcome,ended_by,turns,created_at,ended_at,duration_ms,input_tokens,output_tokens,configuration,provenance
50
+ ) VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)
51
+ ON CONFLICT(id) DO UPDATE SET
52
+ batch_id=excluded.batch_id,launch_id=COALESCE(excluded.launch_id,sessions.launch_id),
53
+ measurement_id=COALESCE(excluded.measurement_id,sessions.measurement_id),
54
+ measurement_kind=COALESCE(excluded.measurement_kind,sessions.measurement_kind),
55
+ measurement_revision=COALESCE(excluded.measurement_revision,sessions.measurement_revision),
56
+ case_path=excluded.case_path,agent=excluded.agent,model=excluded.model,
57
+ current_analysis_id=CASE WHEN excluded.attempt=sessions.attempt THEN sessions.current_analysis_id ELSE NULL END,
58
+ attempt=excluded.attempt,outcome=excluded.outcome,ended_by=excluded.ended_by,turns=excluded.turns,
59
+ ended_at=excluded.ended_at,duration_ms=COALESCE(excluded.duration_ms,sessions.duration_ms),
60
+ input_tokens=COALESCE(excluded.input_tokens,sessions.input_tokens),output_tokens=COALESCE(excluded.output_tokens,sessions.output_tokens),
61
+ configuration=CASE WHEN excluded.configuration='{}' THEN sessions.configuration ELSE excluded.configuration END,
62
+ provenance=CASE WHEN excluded.provenance='{}' THEN sessions.provenance ELSE excluded.provenance END
63
+ WHERE excluded.attempt >= sessions.attempt`).run(input.id,input.batchId,input.launchId??null,input.measurementId??null,input.measurementKind??null,input.measurementRevision??null,input.case,input.agent,input.model,input.attempt,input.outcome,input.endedBy,input.turns,input.createdAt,input.endedAt,input.durationMs??null,input.inputTokens??null,input.outputTokens??null,json(input.configuration??{}),json(input.provenance??{}));return this.getSession(input.id)}getSession(id){const row=this.db.prepare("SELECT * FROM sessions WHERE id = ?").get(id);return row?session(row):void 0}listSessions(filter={}){const conditions=[];const values=[];for(const[key,column]of[["measurementId","measurement_id"],["measurementKind","measurement_kind"],["batchId","batch_id"]]){if(filter[key]!==void 0){conditions.push(`${column} = ?`);values.push(filter[key])}}return this.db.prepare(`SELECT * FROM sessions${conditions.length?` WHERE ${conditions.join(" AND ")}`:""} ORDER BY COALESCE(ended_at,created_at) DESC,id`).all(...values).map(session)}repairSessionSummaries(ids){const runs=join(this.gaugeDir,"runs");if(!existsSync(runs))return{repaired:0,skipped:[]};let repaired=0;const skipped=[];for(const entry of readdirSync(runs,{withFileTypes:true})){if(!entry.isDirectory()||ids&&!ids.includes(entry.name))continue;const attempts=join(runs,entry.name,"attempts");if(!existsSync(attempts))continue;const n=readdirSync(attempts).map(Number).filter(n2=>Number.isInteger(n2)&&n2>0).sort((a,b)=>b-a)[0];if(n===void 0)continue;try{const directory=join(attempts,String(n));const spec=object(readJson(join(directory,"spec.json")));const attempt=object(spec.attempt);const agent=object(spec.agent);if(attempt.runId!==entry.name||attempt.n!==n||typeof attempt.batchId!=="string"||typeof agent.kind!=="string"||typeof agent.model!=="string")throw new Error("invalid spec.json");const result=object(readJson(join(directory,"result.json")));const status=object(readJson(join(directory,"session","status.json")));const item=object(spec.case);const association=object(spec.measurement);const previous=this.getSession(entry.name);const createdAt=typeof spec.createdAt==="string"?spec.createdAt:previous?.createdAt??statSync(join(directory,"spec.json")).mtime.toISOString();this.upsertSession({id:entry.name,batchId:attempt.batchId,launchId:typeof spec.launchId==="string"?spec.launchId:null,measurementId:typeof association.id==="string"?association.id:null,measurementKind:association.kind==="eval"||association.kind==="preference"?association.kind:null,measurementRevision:typeof association.revision==="number"?association.revision:null,case:typeof item.path==="string"?item.path:null,agent:typeof spec.agentName==="string"?spec.agentName:agent.kind,model:agent.model,attempt:n,outcome:String(result.outcome??status.state??"queued"),endedBy:typeof result.endedBy==="string"?result.endedBy:null,turns:typeof result.turns==="number"?result.turns:typeof status.turn==="number"?status.turn:null,createdAt,endedAt:typeof result.endedAt==="string"?result.endedAt:null,durationMs:numberOrNull(result.durationMs),inputTokens:numberOrNull(result.inputTokens),outputTokens:numberOrNull(result.outputTokens),configuration:{...object(spec.configuration),case:item},provenance:object(spec.provenance)});repaired++}catch(error){skipped.push(`${entry.name}: ${error instanceof Error?error.message:String(error)}`)}}return{repaired,skipped}}};function numberOrNull(value){return typeof value==="number"&&Number.isFinite(value)?value:null}function readJson(path){try{return JSON.parse(readFileSync(path,"utf8"))}catch(error){if(error.code==="ENOENT")return void 0;throw error}}function normalizeDefinition(definition){if(!definition.name?.trim()||!definition.promptText?.trim())throw new CliError("usage","A local measurement requires a nonempty name and promptText.");if(definition.tags&&(!Array.isArray(definition.tags)||definition.tags.some(tag=>typeof tag!=="string"||!tag.trim())))throw new CliError("usage","Measurement tags must be nonempty strings.");for(const key of["id","measurementKind","revision","createdAt","updatedAt"]){if(key in definition)throw new CliError("usage",`Measurement field ${key} is assigned by Gauge.`)}return{...definition,tags:[...new Set(definition.tags??[])]}}function measurement(row){return{...parse(row.definition),id:String(row.id),measurementKind:row.kind,revision:Number(row.revision),createdAt:String(row.created_at),updatedAt:String(row.updated_at)}}function session(row){return{id:String(row.id),batchId:String(row.batch_id),launchId:row.launch_id,measurementId:row.measurement_id,measurementKind:row.measurement_kind,measurementRevision:row.measurement_revision,case:row.case_path,agent:String(row.agent),model:String(row.model),attempt:Number(row.attempt),outcome:String(row.outcome),endedBy:row.ended_by,turns:row.turns,createdAt:String(row.created_at),endedAt:row.ended_at,durationMs:row.duration_ms,inputTokens:row.input_tokens,outputTokens:row.output_tokens,configuration:parse(row.configuration),provenance:parse(row.provenance),currentAnalysisId:row.current_analysis_id,analyzed:row.current_analysis_id!==null}}function openLocalStore(gaugeDir){mkdirSync(gaugeDir,{recursive:true,mode:448});const path=join(gaugeDir,"gauge.sqlite");const{DatabaseSync:SQLite}=loadSQLite();const db=new SQLite(path);try{chmodSync(path,384);db.exec("PRAGMA busy_timeout = 5000; PRAGMA foreign_keys = ON;");const version=Number(db.prepare("PRAGMA user_version").get().user_version);if(version>LOCAL_DATABASE_VERSION)throw new CliError("usage",`This workspace uses database version ${version}; this CLI supports ${LOCAL_DATABASE_VERSION}. Upgrade Gauge. Your data has not been changed.`);db.exec("PRAGMA journal_mode = WAL;");if(version===0){db.exec("BEGIN IMMEDIATE");try{if(Number(db.prepare("PRAGMA user_version").get().user_version)===0)db.exec(schema);db.exec("COMMIT")}catch(error){db.exec("ROLLBACK");throw error}}return new LocalStore(gaugeDir,db)}catch(error){db.close();throw error}}function loadSQLite(){const emitWarning=process.emitWarning;process.emitWarning=(warning,...args)=>{if(warning==="SQLite is an experimental feature and might change at any time"&&args[0]==="ExperimentalWarning")return;Reflect.apply(emitWarning,process,[warning,...args])};try{return createRequire(import.meta.url)("node:sqlite")}finally{process.emitWarning=emitWarning}}import{execFile}from"child_process";import{createHash}from"crypto";import{readFile}from"fs/promises";import{promisify}from"util";import{join as join2}from"path";var CredentialError=class extends Error{remedy;constructor(message,remedy){super(message);this.remedy=remedy}};var RENEWAL_MARGIN_S=300;var CLAUDE_RENEWS_WITHIN_S=300;async function readOptional(path){try{return await readFile(path,"utf8")}catch(error){if(error.code==="ENOENT")return void 0;throw error}}function claudeKeychainService(env){const secure=env.CLAUDE_SECURESTORAGE_CONFIG_DIR;const dir=secure!==void 0?secure:env.CLAUDE_CONFIG_DIR;if(!dir)return"Claude Code-credentials";return`Claude Code-credentials-${createHash("sha256").update(dir.normalize("NFC")).digest("hex").slice(0,8)}`}async function readClaudeKeychain(service){if(process.platform!=="darwin")return void 0;try{const{stdout}=await promisify(execFile)("security",["find-generic-password","-s",service,"-w"]);return stdout}catch{return void 0}}function jwtExpiry(token){const payload=token.split(".")[1];if(!payload)return void 0;try{const exp=JSON.parse(Buffer.from(payload,"base64url").toString("utf8")).exp;return typeof exp==="number"?new Date(exp*1e3):void 0}catch{return void 0}}function envFile(name,value,variable){const target=`/run/gauge/${name}`;return{files:[{name,contents:value,target,readonly:true}],exports:[`export ${variable}="$(cat ${target})"`]}}async function claudeCredential(spec,src,read){switch(spec.auth.mode){case"setup_token":{const token=src.env.CLAUDE_CODE_OAUTH_TOKEN?.trim();if(!token)throw new CredentialError("CLAUDE_CODE_OAUTH_TOKEN is not set.","Set CLAUDE_CODE_OAUTH_TOKEN, or use the Claude Code login on this machine.");return envFile("claude-token",token,"CLAUDE_CODE_OAUTH_TOKEN")}case"api_key":return providerApiKey("anthropic",src);case"access_token":{const{access,expiresAt}=await claudeLogin(spec,src,read);return{...envFile("claude-token",access,"CLAUDE_CODE_OAUTH_TOKEN"),expiresAt}}}}async function claudeLogin(spec,src,read){const configDir=src.env.CLAUDE_CONFIG_DIR||join2(src.homeDir,".claude");const raw=await(src.readKeychain??readClaudeKeychain)(claudeKeychainService(src.env))??await read(join2(configDir,".credentials.json"));let login;try{login=raw?JSON.parse(raw).claudeAiOauth:void 0}catch{login=void 0}if(typeof login?.accessToken!=="string"||typeof login.expiresAt!=="number")throw new CredentialError("No Claude Code login found on this machine.","Run `claude` on this machine and log in, or set ANTHROPIC_API_KEY.");const expiresAt=new Date(login.expiresAt);const needed=spec.limits.turnTimeoutS+RENEWAL_MARGIN_S;const remainingMs=expiresAt.getTime()-src.now.getTime();if(remainingMs<needed*1e3){const renewableAt=new Date(expiresAt.getTime()-CLAUDE_RENEWS_WITHIN_S*1e3);throw new CredentialError(`The Claude Code login expires at ${expiresAt.toISOString()}, too soon for a ${spec.limits.turnTimeoutS}s turn.`,remainingMs<=CLAUDE_RENEWS_WITHIN_S*1e3?"Run `claude -p ok` once on this machine to renew its login.":`Claude Code renews its login only in the last ${CLAUDE_RENEWS_WITHIN_S/60} minutes. After ${renewableAt.toISOString()}, run \`claude -p ok\` and retry. Or run \`claude setup-token\` and export the token as CLAUDE_CODE_OAUTH_TOKEN.`)}return{access:login.accessToken,expiresAt}}async function chatGptLogin(spec,src,read){const home=src.env.CODEX_HOME||join2(src.homeDir,".codex");const raw=await read(join2(home,"auth.json"));let auth;try{auth=raw?JSON.parse(raw):void 0}catch{throw new CredentialError("The native Codex login file is invalid.","Run `codex login` on this machine to replace it.")}const access=auth?.tokens?.access_token;if(!auth||auth.auth_mode!=="chatgpt"||!access)throw new CredentialError("No ChatGPT login found (Codex's ~/.codex/auth.json).","Run `codex login` on this machine, or select API-key auth.");const expiresAt=jwtExpiry(access);const needed=spec.limits.turnTimeoutS+RENEWAL_MARGIN_S;if(!expiresAt||expiresAt.getTime()-src.now.getTime()<needed*1e3)throw new CredentialError(`The ChatGPT access token ${expiresAt?`expires at ${expiresAt.toISOString()}`:"has no readable expiry"}, too soon for a ${spec.limits.turnTimeoutS}s turn.`,"Run `codex` once on this machine to renew its login.");return{auth,access,accountId:auth.tokens?.account_id,expiresAt}}var API_KEY_ENV={anthropic:"ANTHROPIC_API_KEY",openai:"OPENAI_API_KEY",fireworks:"FIREWORKS_API_KEY",openrouter:"OPENROUTER_API_KEY"};function providerApiKey(provider,src){const variable=API_KEY_ENV[provider];if(!variable)throw new CredentialError(`API-key auth is not supported for provider ${provider}.`,`Use one of: ${Object.keys(API_KEY_ENV).join(", ")}.`);const key=src.env[variable]?.trim();if(!key)throw new CredentialError(`API-key mode was selected but ${variable} is not set.`,`Export ${variable}, or select subscription auth.`);return envFile(variable.toLowerCase().replace(/_/g,"-"),key,variable)}function noClaudeSubscription(agent){throw new CredentialError(`Claude subscriptions are supported only in Claude Code, not ${agent}.`,"Use an Anthropic API key, or a ChatGPT login with an openai model.")}async function codexCredential(spec,src,read){switch(spec.auth.mode){case"access_token":{const{auth,expiresAt}=await chatGptLogin(spec,src,read);const stripped={...auth,OPENAI_API_KEY:null,tokens:{...auth.tokens,refresh_token:""}};return{files:[{name:"codex-auth.json",contents:JSON.stringify(stripped),target:"/run/gauge/codex-auth.json",readonly:true}],exports:["cp /run/gauge/codex-auth.json /gauge/session/codex/auth.json","chmod 600 /gauge/session/codex/auth.json"],expiresAt}}case"api_key":{const credential=providerApiKey("openai",src);return{...credential,exports:[...credential.exports,"codex login --with-api-key < /run/gauge/openai-api-key"]}}case"setup_token":throw new CredentialError("setup-token auth applies to Claude only.","Use the existing ChatGPT login or an API key for Codex.")}}async function openCodeCredential(spec,src,read){const{provider}=splitModel(spec.agent.model);switch(spec.auth.mode){case"access_token":{if(provider!=="openai")throw new CredentialError(`A ChatGPT login serves only openai/* models in OpenCode, not ${provider}.`,"Choose an openai/<model>, or select API-key auth.");const{access,accountId,expiresAt}=await chatGptLogin(spec,src,read);const content=JSON.stringify({openai:{type:"oauth",access,refresh:"",expires:expiresAt.getTime(),accountId}});return{...envFile("opencode-auth.json",content,"OPENCODE_AUTH_CONTENT"),expiresAt}}case"api_key":return providerApiKey(provider,src);case"setup_token":return noClaudeSubscription("OpenCode")}}async function piCredential(spec,src,read){const{provider}=splitModel(spec.agent.model);const agentDir=`mkdir -p ${PI_AGENT_DIR}`;switch(spec.auth.mode){case"access_token":{if(provider!=="openai-codex")throw new CredentialError(`A ChatGPT login serves only openai-codex/* models in Pi, not ${provider}.`,"Choose an openai-codex/<model>, or select API-key auth.");const{access,accountId,expiresAt}=await chatGptLogin(spec,src,read);const target="/run/gauge/pi-auth.json";return{files:[{name:"pi-auth.json",contents:JSON.stringify({"openai-codex":{type:"oauth",access,refresh:"",expires:expiresAt.getTime(),accountId}}),target,readonly:true}],exports:[agentDir,`cp ${target} ${PI_AGENT_DIR}/auth.json`,`chmod 600 ${PI_AGENT_DIR}/auth.json`],expiresAt}}case"api_key":{const credential=providerApiKey(provider,src);return{...credential,exports:[agentDir,...credential.exports]}}case"setup_token":return noClaudeSubscription("Pi")}}async function resolveSessionCredential(spec,src){const read=src.readFile??readOptional;switch(spec.agent.kind){case"claude-code":return claudeCredential(spec,src,read);case"codex":return codexCredential(spec,src,read);case"opencode":return openCodeCredential(spec,src,read);case"pi":return piCredential(spec,src,read)}}import{spawn}from"child_process";import{randomUUID as randomUUID3}from"crypto";import{chmod,lstat,mkdir as mkdir2,mkdtemp,open as open2,readFile as readFile3,rm as rm2,writeFile}from"fs/promises";import{createConnection}from"net";import{tmpdir}from"os";import{basename,dirname as dirname2,isAbsolute,join as join3,resolve}from"path";import{fileURLToPath}from"url";import{randomUUID as randomUUID2}from"crypto";import{mkdir,open,readFile as readFile2,rename,rm}from"fs/promises";import{dirname}from"path";function tempPath(path){return`${path}.tmp-${process.pid}-${randomUUID2()}`}async function writeSynced(path,data,mode){const handle=await open(path,"wx",mode);try{await handle.writeFile(data);await handle.sync()}finally{await handle.close()}}async function writeFileAtomic(path,data,mode=420){await mkdir(dirname(path),{recursive:true});const tmp=tempPath(path);try{await writeSynced(tmp,data,mode);await rename(tmp,path)}catch(error){await rm(tmp,{force:true});throw error}}function writeJsonAtomic(path,value){return writeFileAtomic(path,`${JSON.stringify(value,null,2)}
64
+ `)}async function readJson2(path){try{return JSON.parse(await readFile2(path,"utf8"))}catch(error){if(error.code==="ENOENT")return void 0;throw error}}var terminal=state=>state==="completed"||state==="failed"||state==="canceled"||state==="interrupted";var SessionNotFoundError=class extends Error{constructor(){super("no supported session in this directory");this.name="SessionNotFoundError"}};var SessionUnavailableError=class extends Error{lastKnownStatus;constructor(message,cause,lastKnownStatus){super(message,{cause});this.lastKnownStatus=lastKnownStatus;this.name="SessionUnavailableError"}};var socketUnavailable=error=>["ENOENT","ECONNREFUSED"].includes(error?.code??"");function validateSpec(spec){if(spec.gateway){validateGateway(spec.gateway);if(process.getuid?.()===65532)throw new Error("Host UID 65532 is reserved for the local gateway")}if(!["claude-code","codex","pi","opencode"].includes(spec.agent.kind))throw new Error("unsupported agent");if(!spec.image||!spec.agent.model||!spec.prompt.text)throw new Error("image, model and prompt are required");if(spec.workspace){const url=new URL(spec.workspace.repo);if(url.protocol!=="https:"||url.hostname!=="github.com"||url.username||url.password||url.search||url.hash||!/^\/[\w.-]+\/[\w.-]+\/?$/.test(url.pathname))throw new Error("workspace must be a public GitHub HTTPS repository URL");if(!spec.workspace.ref||spec.workspace.ref.startsWith("-"))throw new Error("invalid repository ref")}for(const value of[spec.limits.turnTimeoutS,spec.limits.maxTurns])if(!Number.isSafeInteger(value)||value<1)throw new Error("limits must be positive integers");if(spec.limits.responseTimeoutS!==null&&(!Number.isSafeInteger(spec.limits.responseTimeoutS)||spec.limits.responseTimeoutS<1))throw new Error("response timeout must be null or a positive integer");const names=new Set;for(const r of spec.resources){if(!["file","archive"].includes(r.kind))throw new Error("unsupported resource kind");if(!/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(r.name)||names.has(r.name))throw new Error("invalid or duplicate resource name");if(!/^[\w.-]+$/.test(r.filename)||r.filename==="."||r.filename==="..")throw new Error("invalid resource filename");if(!/^sha256:[a-f0-9]{64}$/.test(r.digest))throw new Error("invalid resource digest");if(r.use&&r.kind!=="archive")throw new Error("resource use requires an archive");if(r.use&&!["files","skill","npm-package"].includes(r.use.type))throw new Error("unsupported resource use");if(r.use?.type==="npm-package"&&(!/^[\w.-]+\.tgz$/.test(r.use.package)||!["environment","workspace"].includes(r.use.install)))throw new Error("invalid npm input");names.add(r.name)}}async function startSession(options){validateSpec(options.spec);const directory=resolve(options.directory);const credential=await resolveSessionCredential(options.spec,{...options.credentials,now:new Date});await mkdir2(dirname2(directory),{recursive:true});await mkdir2(directory,{mode:448});let credentialDir;let handedOff=false;const containerName=`gauge-session-${randomUUID3()}`;try{const runtime=options.runtimeDirectory??tmpdir();await mkdir2(runtime,{recursive:true});credentialDir=await mkdtemp(join3(runtime,"gauge-"));await chmod(credentialDir,448);await mkdir2(join3(credentialDir,"workspace"),{mode:448});const record={version:2,containerName,credentialDir,socketPath:join3(credentialDir,"control.sock"),spec:options.spec,credentialExpiresAt:credential.expiresAt?.toISOString(),...options.spec.gateway?{gatewayName:`${containerName}-gateway`,trustContainerName:`${containerName}-trust`}:{}};if(Buffer.byteLength(record.socketPath)>100)throw new Error("runtimeDirectory is too long for a Unix socket");await writeJsonAtomic(join3(directory,"session.json"),record);const mounts=[{type:"bind",source:join3(credentialDir,"workspace"),target:"/gauge/session",readonly:false}];for(const file of credential.files){const source=join3(credentialDir,file.name);await writeFile(source,file.contents,{mode:384});mounts.push({type:"bind",source,target:file.target,readonly:file.readonly})}for(const resource of options.spec.resources){if(!options.blobsDirectory)throw new Error("blobsDirectory is required for resources");mounts.push({type:"bind",source:resolve(options.blobsDirectory,resource.digest.slice(7)),target:`/gauge/inputs/${resource.name}`,readonly:true})}const script=[prepareScript(options.spec),...credential.exports,`exec ${harnessCommand(options.spec).map(shellQuote).join(" ")}`].join("\n");record.workload={name:containerName,image:options.spec.image,interactive:true,user:`${process.getuid()}:${process.getgid()}`,labels:{"sh.gauge.session":containerName},mounts,env:{...agentEnv(options.spec.agent.kind),HOME:"/gauge/session/home"},command:["sh","-c",script]};await writeJsonAtomic(join3(directory,"session.json"),record);const initial={state:"preparing",turn:0,updatedAt:new Date().toISOString(),cleanupPending:true};await writeJsonAtomic(join3(directory,"status.json"),{...initial,driverPid:process.pid});const log=await open2(join3(directory,"driver.log"),"a",384);try{const child=spawn(process.execPath,[fileURLToPath(new URL("./worker.js",import.meta.url)),directory],{detached:true,stdio:["ignore",log.fd,log.fd],env:Object.fromEntries(Object.entries(process.env).filter(([key])=>!/(?:API_KEY|AUTH_TOKEN|OAUTH_TOKEN|ACCESS_TOKEN|REFRESH_TOKEN)$/.test(key)))});const spawned=new Promise((yes,no)=>{child.once("spawn",yes);child.once("error",no)});await spawned;handedOff=true;child.unref();await writeJsonAtomic(join3(directory,"status.json"),{...initial,driverPid:child.pid});await writeFile(join3(credentialDir,"handoff"),"ready\n",{mode:384})}finally{await log.close()}const deadline=Date.now()+1e4;while(Date.now()<deadline){try{return await request(record.socketPath,{action:"status"})}catch{const saved=await readJson2(join3(directory,"status.json"));if(saved&&terminal(saved.state))return saved;await new Promise(r=>setTimeout(r,50))}}throw new Error("host session process did not start; see driver.log")}catch(error){if(handedOff)throw error;if(credentialDir)await rm2(credentialDir,{recursive:true,force:true});await writeJsonAtomic(join3(directory,"status.json"),{state:"failed",turn:0,updatedAt:new Date().toISOString(),detail:String(error)});throw error}}async function request(socketPath,command2,timeoutMs=35e3){return new Promise((resolve2,reject)=>{const socket=createConnection(socketPath);let bytes="";socket.setEncoding("utf8");const deadline=setTimeout(()=>socket.destroy(new Error("session command timed out; delivery may have succeeded")),timeoutMs);socket.on("close",()=>clearTimeout(deadline));socket.on("error",reject);socket.on("connect",()=>socket.write(JSON.stringify(command2)+"\n"));socket.on("data",chunk=>{bytes+=chunk;if(Buffer.byteLength(bytes)>8*1024*1024){socket.destroy(new Error("session response too large"));return}if(bytes.includes("\n")){try{resolve2(JSON.parse(bytes.slice(0,bytes.indexOf("\n"))))}catch(e){reject(e)}socket.end()}});socket.on("end",()=>{if(!bytes.includes("\n"))reject(new Error("session disconnected before acknowledging command"))})})}async function launchRecord(directory){const record=await readJson2(join3(directory,"session.json"));if(!record)throw new SessionNotFoundError;if(record.version!==1&&record.version!==2)throw new Error("Unsupported session record version");return record}async function getSessionStatus(directory,options={}){const record=await launchRecord(directory);const saved=await readJson2(join3(directory,"status.json"));if(saved&&terminal(saved.state))return saved;try{return await request(record.socketPath,{action:"status"},options.timeoutMs)}catch(error){const latest=await readJson2(join3(directory,"status.json"));if(latest&&terminal(latest.state))return latest;throw new SessionUnavailableError("Session status is unavailable; the driver may still be running. Check status again before taking action.",error,latest??saved??void 0)}}async function command(directory,value){const record=await launchRecord(directory);let receipt;try{receipt=await request(record.socketPath,value)}catch(error){throw new SessionUnavailableError("Session command was not acknowledged; delivery may have succeeded. Check status before retrying.",error)}if(!receipt.accepted)throw new Error(receipt.error??"session rejected command");return receipt}var finishSession=(directory,expectedTurn)=>command(directory,{action:"finish",turn:expectedTurn});async function stopSession(directory){const record=await launchRecord(directory);let saved=await readJson2(join3(directory,"status.json"));if(saved&&terminal(saved.state)&&!saved.cleanupPending)return;let receipt;try{receipt=await request(record.socketPath,{action:"cancel"})}catch(error){saved=await readJson2(join3(directory,"status.json"));if(saved&&terminal(saved.state)&&!saved.cleanupPending)return;if(!socketUnavailable(error)||!saved||!terminal(saved.state))throw new SessionUnavailableError("Cancellation was not acknowledged; the driver may still be running. Check status before retrying.",error);await retryTerminalCleanup(directory,record,saved);return}if(!receipt.accepted)throw new Error(receipt.error??"session rejected cancellation");const deadline=Date.now()+3e4;while(Date.now()<deadline){saved=await readJson2(join3(directory,"status.json"));if(saved&&terminal(saved.state)){if(saved.cleanupPending)throw new Error(saved.detail??"Cleanup incomplete; call stopSession again after the driver exits");return}await new Promise(r=>setTimeout(r,100))}throw new SessionUnavailableError("Cancellation was accepted but cleanup is still pending. Check status; the driver retains ownership of cleanup.")}async function retryTerminalCleanup(directory,record,saved){if(!/^gauge-session-[a-f0-9-]{36}$/.test(record.containerName)||!isAbsolute(record.credentialDir)||!/^gauge-[A-Za-z0-9]+$/.test(basename(record.credentialDir))||record.socketPath!==join3(record.credentialDir,"control.sock"))throw new Error("Refusing cleanup: invalid Gauge runtime ownership record");if(record.gatewayName&&(record.gatewayName!==`${record.containerName}-gateway`||record.trustContainerName!==`${record.containerName}-trust`))throw new Error("Refusing cleanup: invalid gateway ownership record");try{if(!(await lstat(record.credentialDir)).isDirectory())throw new Error("Refusing cleanup: Gauge runtime is not a directory")}catch(error){if(error.code!=="ENOENT")throw error}const engine=new DockerCli;try{await engine.assertSessionOwner(record.containerName,record.credentialDir);await engine.stop(record.containerName,2);const workspace=await preserveWorkspace(directory,record.credentialDir);await engine.remove(record.containerName);await cleanupGateway(record,directory,engine);await rm2(record.credentialDir,{recursive:true,force:true});await writeJsonAtomic(join3(directory,"status.json"),{...saved,turn:saved.turn,updatedAt:new Date().toISOString(),question:void 0,cleanupPending:false,detail:saved.detail,artifacts:workspace?{...saved?.artifacts,workspace}:saved?.artifacts})}catch(error){await writeJsonAtomic(join3(directory,"status.json"),{...saved,turn:saved.turn,updatedAt:new Date().toISOString(),cleanupPending:true,detail:`Cleanup incomplete: ${String(error)}; retry stopSession after resolving the error`});throw error}}import{existsSync as existsSync2,statSync as statSync2}from"fs";import{lstat as lstat2,readdir,readFile as readFile4,writeFile as writeFile2}from"fs/promises";import{join as join4}from"path";function localId(id){if(!/^[a-zA-Z0-9_-]+$/.test(id))throw new CliError("usage","Invalid local ID");return id}var batchDirectory=(gaugeDir,id)=>join4(gaugeDir,"batches",localId(id));var cancellationRequested=directory=>existsSync2(join4(directory,"cancel"));async function directories(path){try{if(!(await lstat2(path)).isDirectory())return[];return(await readdir(path,{withFileTypes:true})).filter(d=>d.isDirectory()).map(d=>d.name)}catch(error){if(error.code==="ENOENT")return[];throw error}}async function localSessions(gaugeDir){const sessions=[];for(const id of await directories(join4(gaugeDir,"runs"))){const attempts=join4(gaugeDir,"runs",id,"attempts");for(const n of await directories(attempts)){const attempt=join4(attempts,n);try{if(!(await lstat2(join4(attempt,"spec.json"))).isFile())continue;const spec=JSON.parse(await readFile4(join4(attempt,"spec.json"),"utf8"));if(spec.attempt?.runId!==id||String(spec.attempt.n)!==n||typeof spec.attempt.batchId!=="string")continue;const directory=join4(attempt,"session");if(existsSync2(directory)&&!(await lstat2(directory)).isDirectory())continue;sessions.push({id,batchId:spec.attempt.batchId,directory})}catch(error){if(!(error instanceof SyntaxError)&&error.code!=="ENOENT")throw error}}}return sessions}async function resultDetail(directory){try{const result=JSON.parse(await readFile4(join4(directory,"..","result.json"),"utf8"));return typeof result.detail==="string"?result.detail:void 0}catch{return}}function stderrLog(directory,state){if(state!=="failed")return;const path=join4(directory,"agent.stderr.log");try{return statSync2(path).size?path:void 0}catch{return}}async function localStatus(gaugeDir,filter={}){const sessions=(await localSessions(gaugeDir)).filter(s=>(!filter.id||s.id===filter.id)&&(!filter.batch||s.batchId===filter.batch));return Promise.all(sessions.map(async session2=>{try{const status=await getSessionStatus(session2.directory,{timeoutMs:1e3});return{id:session2.id,batchId:session2.batchId,state:status.state,turns:status.turn,cleanupPending:status.cleanupPending??false,detail:status.detail??await resultDetail(session2.directory),stderrLog:stderrLog(session2.directory,status.state)}}catch(error){try{const result=JSON.parse(await readFile4(join4(session2.directory,"..","result.json"),"utf8"));return{id:session2.id,batchId:session2.batchId,state:result.outcome,turns:result.turns,detail:result.detail,stderrLog:stderrLog(session2.directory,result.outcome)}}catch{}return{id:session2.id,batchId:session2.batchId,state:"unavailable",lastKnownState:error instanceof SessionUnavailableError?error.lastKnownStatus?.state:void 0,turns:error instanceof SessionUnavailableError?error.lastKnownStatus?.turn:void 0,detail:String(error),stderrLog:void 0}}}))}async function cancelLocal(gaugeDir,filter){if(Boolean(filter.id)===Boolean(filter.batch))throw new CliError("usage","Pass a run ID or --batch <batch-id>");if(filter.id)localId(filter.id);if(filter.batch)localId(filter.batch);const sessions=(await localSessions(gaugeDir)).filter(s=>filter.id?s.id===filter.id:s.batchId===filter.batch);if(filter.batch){const directory=batchDirectory(gaugeDir,filter.batch);if(existsSync2(directory)){if(!(await lstat2(directory)).isDirectory())throw new CliError("usage","Cannot cancel this batch because its folder is a symbolic link.",{hint:"Run the command from the original Gauge workspace."});await writeFile2(join4(directory,"cancel"),"",{mode:384})}else if(!sessions.length)throw new CliError("not_found","Local batch not found")}else if(!sessions.length)throw new CliError("not_found","Local run not found");for(const session2 of sessions)await writeFile2(join4(session2.directory,"..","cancel"),"",{mode:384});return Promise.all(sessions.map(async session2=>{try{await stopSession(session2.directory);return{id:session2.id,status:"stopped"}}catch(error){return{id:session2.id,status:"pending",detail:String(error)}}}))}async function cleanupLocal(gaugeDir){const results=[];for(const session2 of await localSessions(gaugeDir)){if(!existsSync2(join4(session2.directory,"session.json")))continue;try{const status=await getSessionStatus(session2.directory);if(status.state!=="interrupted"&&!status.cleanupPending)continue;await stopSession(session2.directory);const final=await getSessionStatus(session2.directory);try{await writeFile2(join4(session2.directory,"..","result.json"),JSON.stringify({outcome:final.state,endedBy:"recovery",turns:final.turn,endedAt:final.updatedAt,detail:final.detail})+"\n",{flag:"wx",mode:384})}catch(error){if(error.code!=="EEXIST")throw error}const store=openLocalStore(gaugeDir);try{const{skipped}=store.repairSessionSummaries([session2.id]);if(skipped.length)throw new Error(skipped.join("; "))}finally{store.close()}results.push({id:session2.id,status:"cleaned"})}catch(error){results.push({id:session2.id,status:"error",detail:String(error)})}}return results}async function localBatchStatus(gaugeDir,id){const directory=batchDirectory(gaugeDir,id);const status=JSON.parse(await readFile4(join4(directory,"status.json"),"utf8"));if(status.state==="running"||status.state==="queued"){status.lastKnownState=status.state;status.state="unavailable";status.detail="Batch supervisor status is unavailable; showing last recorded progress."}return{...status,cancelRequested:cancellationRequested(directory)}}export{openLocalStore,CredentialError,resolveSessionCredential,SessionUnavailableError,startSession,getSessionStatus,finishSession,stopSession,localId,batchDirectory,cancellationRequested,localStatus,cancelLocal,cleanupLocal,localBatchStatus};
@@ -0,0 +1 @@
1
+ import{credentialKind,fetchDirectory,isUuid,keyOrganization,legacySelection,resolveSelection}from"./chunk-AZKXHO6C.js";import{ApiClient,CliError,codeForStatus,resolveAuthUrl,resolveToken,retryAfterSeconds,storedSharedCredentials}from"./chunk-PMX3NOGH.js";import{readConfig}from"./chunk-OIGVDK3F.js";import{existsSync,readFileSync}from"fs";import{dirname,join,resolve}from"path";function findWorkspace(cwd=process.cwd()){let directory=resolve(cwd);while(true){if(existsSync(join(directory,"gauge.json"))||existsSync(join(directory,".gauge","config.json")))return directory;const parent=dirname(directory);if(parent===directory)return void 0;directory=parent}}function gaugeState(command,cwd=process.cwd()){return readGaugeState(command.optsWithGlobals(),cwd)}function backend(value,location){if(value===void 0)return void 0;if(value==="local"||value==="hosted")return value;throw new CliError("usage",`Invalid backend in ${location}: expected local or hosted`)}function readGaugeState(flags,cwd=process.cwd(),account={signedIn:resolveToken()!==null,...readConfig()}){const root=findWorkspace(cwd);let config;let workspaceBackend;if(root){if(!existsSync(join(root,"gauge.json")))config={};else try{const parsed=JSON.parse(readFileSync(join(root,"gauge.json"),"utf8"));config=parsed&&typeof parsed==="object"&&!Array.isArray(parsed)?parsed:null}catch{config=null}if(config&&"mode"in config)throw new CliError("usage","gauge.json does not accept mode. Set backend in private .gauge/config.json; keep the project manifest backend-independent.");const path=join(root,".gauge","config.json");if(existsSync(path)){let value;try{value=JSON.parse(readFileSync(path,"utf8"))}catch{throw new CliError("usage",`${path} is not valid JSON`)}if(!value||value.version!==1)throw new CliError("usage",`Unsupported workspace configuration version in ${path}`);workspaceBackend=backend(value.backend,path)}}const userBackend=backend(account.backend,"user configuration");const[mode,source]=flags.local?["local","flag"]:flags.hosted?["hosted","flag"]:workspaceBackend?[workspaceBackend,"workspace"]:userBackend?[userBackend,"user"]:["local","default"];return{mode,source,root,inRepo:root!==void 0,config,signedIn:account.signedIn,orgId:account.orgId}}function instructionMode(state){const why={flag:"from the flag",workspace:"from .gauge/config.json",user:"from user configuration",default:"the default"};return{mode:state.mode,why:why[state.source]}}function header(state,topic,brief=false){const{mode,why}=instructionMode(state);const lines=[`Mode: ${mode} (${why}). Pass --${mode==="local"?"hosted":"local"} to switch for this command.`];if(mode==="local"&&topic&&!topic.local&&!topic.shared)lines.push("This topic is hosted only. Local guidance: `gauge instructions --local`.");if(state.config===null)lines.push("gauge.json is not valid JSON. Fix it before using this workspace.");else if(!state.root&&!brief)lines.push("Run `gauge init` to initialize this directory. It writes only private .gauge/ state. Add --cases to also write shared gauge.json, gauge-cases/, and an AGENTS.md block.");else if(!brief&&(!topic||topic.key==="root"))lines.push("Next: `gauge instructions eval` or `gauge instructions preference` to create a saved measurement; `gauge instructions run` to launch it.");return lines}function selectedOrg(command,fileOrg){const{org}=command.optsWithGlobals();if(org)return{value:org,source:"flag"};if(fileOrg)return{value:fileOrg,source:"file"};const project=gaugeState(command).config;if(typeof project?.orgId==="string"&&project.orgId){if(!isUuid(project.orgId))throw new CliError("usage","The organization saved in gauge.json is not valid.",{hint:"Run `gauge orgs`, then `gauge orgs use <slug> --project` to choose this project's organization."});return{value:project.orgId,source:"project"}}if(project?.org)legacySelection("project");const{orgId,defaultOrg}=readConfig();if(orgId){if(!isUuid(orgId))throw new CliError("usage","Your saved organization is not valid.",{hint:"Run `gauge orgs`, then `gauge orgs use <slug>` to choose your organization."});return{value:orgId,source:"config"}}if(defaultOrg)legacySelection("config");return void 0}var NO_ORG_MESSAGE="No organization selected. Pass --org <org> or set a default with `gauge orgs use <org>`.";async function resolveOrg(command,fileOrg){const selection=selectedOrg(command,fileOrg);if(!selection)throw new CliError("usage",NO_ORG_MESSAGE,{needsAccount:true});return(await resolveSelection(selection.value,selection.source)).id}function resolveOutput(command){const{output}=command.optsWithGlobals();return output==="json"?"json":"table"}function requireHosted(command,{account=false,hint}={}){const{mode,source}=gaugeState(command);if(mode==="local"&&(source==="flag"||!account))throw new CliError("usage","This command needs hosted Gauge.",{needsAccount:true,hint})}function hostedOnly(command,options={}){return command.hook("preAction",(_command,action)=>requireHosted(action,options))}var OUTPUT_FORMATS=["table","json"];function colorEnabled(stream){if(process.env.FORCE_COLOR)return process.env.FORCE_COLOR!=="0";return stream.isTTY===true&&!process.env.NO_COLOR&&process.env.TERM!=="dumb"}function style(code,stream=process.stdout){const on=colorEnabled(stream);return text=>on?`\x1B[${code}m${text}\x1B[0m`:text}function printJson(value){console.log(JSON.stringify(value,null,2))}function printItems(items,format,columns){if(format==="json"){printJson(items);return}if(items.length===0){console.log("(no results)");return}const cols=columns??Object.keys(items[0]).map(key=>({key}));const headers=cols.map(col=>col.header??col.key);const rows=items.map(item=>cols.map(col=>cell(item[col.key])));const widths=headers.map((header2,i)=>Math.max(header2.length,...rows.map(row=>row[i].length)));const line=values=>values.map((value,i)=>value.padEnd(widths[i])).join(" ").trimEnd();console.log(line(headers));for(const row of rows)console.log(line(row))}function cell(value){if(value===null||value===void 0||value==="")return"\u2014";if(value instanceof Date)return value.toISOString();if(typeof value==="object")return JSON.stringify(value);return String(value)}var CHAT_API_PREFIX="/api/v1";var CHAT_BATCH_SIZE=500;var INVALID_CODES=new Set(["invalid_request","invalid_query","invalid_id","invalid_cursor","range_too_large"]);function exitFamily(status,code){if(code==="limit_exceeded")return"insufficient_credits";if(status===400||status===422||INVALID_CODES.has(code))return"invalid_request";if(code==="rate_limited")return"rate_limited";return codeForStatus(status)}function isChatErrorBody(value){const error=value?.error;return typeof error==="object"&&error!==null&&typeof error.code==="string"&&typeof error.message==="string"}function loginHint(){return process.env.GAUGE_API_TOKEN?.trim()?"Replace GAUGE_API_TOKEN with a valid key, or unset it and run `gauge auth login`.":"Run `gauge auth login`, or set GAUGE_API_TOKEN to an org API key (Settings \u2192 API Keys)."}function hintFor(code,field,extra,retryAfter){switch(code){case"forbidden":return field==="explain"?"--explain (or `explain` in --json) is only available to Gauge staff; rerun without it.":void 0;case"unauthorized":return loginHint();case"insufficient_scope":return extra.requiredScope&&extra.requiredScope!=="write"?`Ask an organization admin for '${String(extra.requiredScope)}' permission.`:"Ask an organization admin for write access, or create a Read & write API key in Settings \u2192 API Keys.";case"limit_exceeded":return typeof extra.remaining==="number"?`Your plan allows ${extra.remaining} more prompt(s); nothing was created.`:"Nothing was created.";case"rate_limited":return retryAfter===void 0?"Retry shortly.":`Retry in ${retryAfter} s.`;case"product_not_enabled":return"Run `gauge orgs` to see which products each organization uses.";default:return void 0}}function describeScopes(scopes){if(scopes.includes("write"))return"read & write";if(scopes.length===1&&scopes[0]==="read")return"read-only";return scopes.length?scopes.join(", "):"no permissions"}var ChatApiClient=class extends ApiClient{describingScope=false;orgName;async me(){try{return await this.get(chatPath("me"))}catch(error){if(!(error instanceof CliError)||error.code!=="not_found")throw error;throw new CliError("not_found","This Gauge server cannot show your account details yet.",{hint:"Run `gauge orgs` to check your access. If you use a custom Gauge server, ask its administrator to update it."})}}async scopeHint(required){if(this.describingScope)return void 0;this.describingScope=true;try{const{token}=await this.me();const needs=String(required??"write");const access=token.scopes.length?`${describeScopes(token.scopes)} access`:"no permissions";if(token.kind==="api_key")return`This API key has ${access}.${needs==="write"?" Create a Read & write key in Settings \u2192 API Keys, then update GAUGE_API_TOKEN or import it with `gauge auth login --with-token`.":` Use a key with '${needs}' permission.`}`;if(token.kind==="session")return`Your login has ${access}. Ask an organization admin for ${needs==="write"?"write access":`'${needs}' permission`}.`;return void 0}catch{return void 0}finally{this.describingScope=false}}constructor(options={}){super({...options,baseUrl:options.baseUrl??storedSharedCredentials()?.authUrl??resolveAuthUrl()})}headers(extra){if(!this.signedIn)throw new CliError("unauthorized","Not logged in to Gauge.",{hint:loginHint()});return super.headers(extra)}async toError(res){let body;try{body=await res.clone().json()}catch{}if(!isChatErrorBody(body)){if(res.status===404)return unknownEndpoint(res);return super.toError(res)}const{code,message,field,...extra}=body.error;const retryAfter=typeof extra.retryAfter==="number"?extra.retryAfter:res.status===429?retryAfterSeconds(res):void 0;const details={status:res.status,...field?{field}:{},...extra,...retryAfter!==void 0?{retryAfter}:{}};if(code==="product_not_enabled"&&this.orgName)return new CliError(exitFamily(res.status,code),`${this.orgName} doesn't use Gauge Chat.`,{apiCode:code,details,hint:hintFor(code,field,extra,retryAfter)});return new CliError(exitFamily(res.status,code),`${code==="insufficient_scope"?"You don't have the permissions needed for this command.":message}${field?` (field: ${field})`:""}`,{apiCode:code,details,hint:(code==="insufficient_scope"?await this.scopeHint(extra.requiredScope):void 0)??hintFor(code,field,extra,retryAfter)})}};function unknownEndpoint(res){const url=res.url?new URL(res.url):void 0;return new CliError("not_found",`This Gauge server${url?` (${url.host})`:""} does not support this command at the requested address.`,{details:{status:404,...url?{path:url.pathname}:{}},hint:"Check GAUGE_AUTH_URL or `gauge config get authUrl` if you use a custom server. Otherwise, contact Gauge support."})}function createChatApiClient(options={}){return new ChatApiClient(options)}function chatPath(...segments){return`${CHAT_API_PREFIX}/${segments.map(encodeURIComponent).join("/")}`}async function resolveChatOrg(command){const{org}=command.optsWithGlobals();const isKey=credentialKind()==="api_key";const selection=isKey?org?{value:org,source:"flag"}:void 0:selectedOrg(command);if(selection){const resolved=await resolveSelection(selection.value,selection.source);return{id:resolved.id,name:resolved.name,source:selection.source}}if(isKey){const keyOrg=await keyOrganization();return{id:keyOrg.id,name:keyOrg.name,source:"key"}}const chatOrgs=(await fetchDirectory()).filter(o=>o.products?.chat!==false);if(chatOrgs.length===1)return{id:chatOrgs[0].id,name:chatOrgs[0].name,source:"only"};throw new CliError("usage",chatOrgs.length===0?"You are not a member of any organization with Gauge Chat.":`Several organizations have Gauge Chat (${chatOrgs.map(o=>o.slug).join(", ")}). Pass --org <org> or run \`gauge orgs use <org>\`.`)}async function resolveChatCategory(command,client,org){const{category}=command.optsWithGlobals();if(category)return category;const{chatCategory,chatCategoryOrg}=readConfig();if(chatCategory&&(chatCategoryOrg?chatCategoryOrg===org.id:org.source==="config"))return chatCategory;const{data}=await client.get(chatPath("orgs",org.id,"categories"));if(data.length===1)return data[0].slug;const label=org.name??org.id;throw new CliError("usage",data.length===0?`Organization ${label} has no categories.`:`Organization ${label} has several categories (${data.map(c=>c.slug).join(", ")}). Pass --category <slug> or run \`gauge chat categories use <slug>\`.`)}async function chatScope(command){const client=createChatApiClient();const chatOrg=await resolveChatOrg(command);client.orgName=chatOrg.name??chatOrg.id;return{client,org:chatOrg.id,chatOrg}}async function categoryScope(command){const scope=await chatScope(command);const category=await resolveChatCategory(command,scope.client,scope.chatOrg);return{...scope,category,base:["orgs",scope.org,"categories",category]}}var DEFAULT_MAX_ITEMS=5e3;function parsePositive(raw,flag,max){if(raw===void 0)return void 0;const value=Number(raw);if(!Number.isInteger(value)||value<1||max&&value>max)throw new CliError("usage",`${flag} must be an integer${max?` between 1 and ${max}`:" of at least 1"}`);return value}async function fetchPages(client,path,query,options,maxLimit=200){const limit=parsePositive(options.limit,"--limit",maxLimit);if(!options.all)return client.get(path,{...query,limit,cursor:options.cursor});const max=parsePositive(options.max,"--max")??DEFAULT_MAX_ITEMS;const data=[];let cursor=options.cursor;do{const page=await client.get(path,{...query,limit:Math.min(limit??maxLimit,max-data.length),cursor});data.push(...page.data);cursor=page.nextCursor??void 0}while(cursor&&data.length<max);return{data,nextCursor:cursor??null}}async function fetchAll(client,path,query={}){return(await fetchPages(client,path,query,{all:true})).data}function printPage(page,output,row){if(output==="json"){printJson({data:page.data,nextCursor:page.nextCursor??null});return}printItems(page.data.map(row),"table");if(page.nextCursor)console.error(`(more results \u2014 rerun with --cursor ${page.nextCursor}, or pass --all)`)}function addPageOptions(command,maxLimit=200){return command.option("--limit <n>",`page size (1-${maxLimit})`).option("--cursor <cursor>","resume from a previous page's nextCursor").option("--all","follow nextCursor through every page").option("--max <n>",`with --all, stop after this many items (default ${DEFAULT_MAX_ITEMS})`)}function chunks(items,size=CHAT_BATCH_SIZE){const out=[];for(let i=0;i<items.length;i+=size)out.push(items.slice(i,i+size));return out}var csv=raw=>raw.split(",").map(s=>s.trim()).filter(Boolean);function truncate(text,length=80){const flat=text.replace(/\s+/g," ").trim();return flat.length>length?`${flat.slice(0,length-1)}\u2026`:flat}var lower=s=>s.trim().toLowerCase();async function resolveTopicId(scope,value){if(value.startsWith("top_"))return value;const topics=await fetchAll(scope.client,chatPath(...scope.base,"topics"));const match=topics.filter(t=>t.slug===value||lower(t.title)===lower(value));if(match.length===1)return match[0].id;throw new CliError("not_found",match.length?`Topic "${value}" is ambiguous; pass its id (${match.map(t=>t.id).join(", ")}).`:`Topic "${value}" not found in category ${scope.category}.`,{hint:"Run `gauge chat topics list`, or create it with `gauge chat topics create`."})}async function resolveTagIds(scope,values){if(values.every(v=>v.startsWith("tag_")))return values;const tags=await fetchAll(scope.client,chatPath("orgs",scope.org,"tags"));return values.map(value=>{if(value.startsWith("tag_"))return value;const match=tags.filter(t=>lower(t.name)===lower(value));if(match.length===1)return match[0].id;throw new CliError("not_found",match.length?`Tag "${value}" is ambiguous; pass its id (${match.map(t=>t.id).join(", ")}).`:`Tag "${value}" not found.`,{hint:"Run `gauge chat tags list`, or create it with `gauge chat tags create`."})})}function withCategory(command){return command.option("--category <category>","category slug or cat_ id (default: chatCategory config, else the org's only category)")}export{findWorkspace,gaugeState,readGaugeState,instructionMode,header,selectedOrg,resolveOrg,resolveOutput,requireHosted,hostedOnly,OUTPUT_FORMATS,style,printJson,printItems,CHAT_API_PREFIX,CHAT_BATCH_SIZE,describeScopes,ChatApiClient,createChatApiClient,chatPath,resolveChatOrg,resolveChatCategory,chatScope,categoryScope,DEFAULT_MAX_ITEMS,parsePositive,fetchPages,fetchAll,printPage,addPageOptions,chunks,csv,truncate,resolveTopicId,resolveTagIds,withCategory};