commandmate 0.33.3 → 0.34.1

package/README.md

@@ -12,12 +12,14 @@
 **[commandmate website →](https://kewton.github.io/CommandMate/)**
 
 <p align="center">
-  <img src="./docs/images/demo-hero.en.gif" width="600" alt="Switch repos from the tab bar, delegate to another agent from the chat, open the file it names, and do the same from a phone" />
+  <img src="./docs/images/demo-hero.en.gif" width="560" alt="A list of four open issues, one message typed into the lead session, four worktree sessions in the sidebar, a worker writing a test file, and a final report with a phase-by-phase table" />
 </p>
 
-> **From vibe coding to Vibe Engineering.**
+> **One agent leads. Gates decide what's done.**
 
-Vibe Engineering — the AI does the building; the system, not your expertise, guarantees the engineering.
+CommandMate gives your lead agent the machinery to run the others: one Git worktree and one contract per task, gates that decide what is done, and a record of every run. Claude Code, Codex, Antigravity, Command Code, OpenCode, Gemini CLI, Copilot and local models. You approve; you don't relay.
+
+Open source (MIT) · runs on your machine · macOS / Linux / Windows (WSL2) · no app to install
 
 ```bash
 npx commandmate@latest
@@ -27,68 +29,183 @@ npx commandmate@latest
 
 ---
 
-CommandMate adds the machinery — a contract before the work, verification gates after it, Skills that carry the method — on top of the agent CLIs you already use.
-It does not replace tmux, Git worktrees, your terminal, or your agent CLI. It puts a frame around them, so the work arrives verified instead of merely finished.
+## More agents, same you
+
+- The agents are parallel. You are still single-threaded.
+- From the outside, an idle agent and one waiting on you look the same.
+- The agent's summary of what it did is not evidence of what it did.
+- Nobody can safely merge a PR that nobody understands.
+
+CommandMate puts the machinery around the CLIs you already run: a lead that hands out contracts, session state read from the agents' own hooks, gates after the work, and the record in between.
+
+---
+
+## One agent leads
+
+One message to your lead session. It plans the issues — dependencies, file conflicts, waves — and hands each one to a worker in its own worktree under a contract. Gates decide which work comes back. Only what passed becomes a PR, gets merged, and goes through acceptance. Nothing mutates without an explicit approve, and a failed gate stops the run.
+
+```yaml
+# .commandmate/tasks/issue-21.yaml
+version: 1
+title: "Issue #21: pick(obj, keys)"
+goal: |
+  Implement pick(obj, keys) in src/util/pick.js with node:test cases in tests/pick.test.mjs.
+  Run npm test, then commit.
+scope:
+  allow:
+    - "src/util/pick.js"
+    - "tests/pick.test.mjs"
+verify:
+  gates: [unit]
+```
+
+> The scope gate and the work-evidence gate are built in and run on every contract; you declare only the gates that need your project's commands.
+
+### Measured
+
+| Run | Lead | Workers | Result |
+|---|---|---|---|
+| 4 issues, one message | Claude Code | 4 × Claude Code | 4/4 gates passed, 2 waves, PRs merged, UAT go, 8 min 39 s |
+| 4 issues, one message | Command Code | 4 × Command Code | 4/4 gates passed, 7 min 46 s; then a human pulled develop: 47/47 tests |
+| 1 issue, with a review step | Command Code | Codex builds, Claude Code tests, Antigravity reviews | Review REJECT → fix → APPROVE, RESULT passed |
+
+as observed
+
+The lead is a session like any other: today it has been measured with Claude Code and Command Code. Any of the eight agents can take the work. It is a run, not a resident agent: it starts on your message and ends with a report.
+
+---
 
 ## Verified, not vibe-checked
 
-Gates you declared decide whether the work is done, and the exit code is the verdict.
+Gates you declared decide whether the work is done, and the exit code is the verdict: `0` passed, `20` failed, `21` no evidence of work. The agent's summary of what it did is not the evidence. The run is, and `verify history` keeps it.
 
 <p align="center">
   <img src="./docs/images/demo-contract-verify.gif" width="600" alt="A task contract is sent, the verification gates run, and the exit code returns RESULT passed" />
 </p>
 
+If this is the kind of AI development workflow you want, [give the repo a star](https://github.com/Kewton/CommandMate).
+
+---
+
+## Review by another agent
+
+A session can hand its work to another session for review — `commandmate ask`, or the `cmate-delegate` Skill — and the answer comes back to the lead. In the measured run, Command Code led, Codex built, Claude Code wrote the tests, and Antigravity rejected the first version before approving the fix. This is a step you add; the orchestrate runner does not run a cross-model review for you.
+
+---
+
+## Know which one needs you
+
+Waiting is a state read from the agent's hooks, not a guess from the screen. The waiting session shows up as a badge, a toast, the tab title, a PWA badge and a push notification, and you answer from your phone — no app to install.
+
+<p align="center">
+  <img src="./docs/images/demo-sessions.gif" width="560" alt="A sidebar of four sessions with one amber row marked Approve / Reject and a RESULT Passed chip in the header; the waiting session's Create File confirmation is answered with 1. Yes and the list comes back all green" />
+</p>
+
 Works on desktop and mobile — monitor and steer sessions from any browser, including your phone.
 
-If this is the kind of AI development workflow you want, [give the repo a star](https://github.com/Kewton/CommandMate).
+<p align="center">
+  <img src="./docs/images/demo-ux.en.gif" width="600" alt="Switch repos from the tab bar, delegate to another agent from the chat, open the file it names, and do the same from a phone" />
+</p>
 
 ---
 
-## Key Features
+## What it gives you
+
+### One agent leads
+
+| Feature | What it does | Why it matters |
+|---------|-------------|----------------|
+| **cmate-orchestrate Skill** | Plans several issues at once and hands each one out with its own contract: `plan` → `dispatch` → `merge` → `uat` | Nothing mutates without `--approve`, and a failed gate stops the run |
+| **Delegation between sessions** | `commandmate ask` puts a question to another session and brings the answer back; `ask --async` with `commandmate relays` when you would rather not wait, `commandmate peers` to see who is reachable, and the `cmate-delegate` Skill for the pattern | One session can hand work to another, and it works across agent CLIs |
+| **Git Worktree Sessions** | One session per worktree, parallel execution | Multiple issues progress simultaneously without interference |
+| **Multi-Agent Support** | Choose Claude Code, Codex, Gemini CLI, Copilot, OpenCode, Antigravity, Command Code or local models per worktree | Pick the right agent for each task |
+| **Auto Yes Mode** | Agent runs without stopping for confirmations | Optional unattended mode for trusted workflows — review the Security section before enabling |
+
+### Verified, not vibe-checked
 
 | Feature | What it does | Why it matters |
 |---------|-------------|----------------|
 | **Task Contract** | Declare the goal, the changeable scope and the gates before the work starts, then `send --contract` hands them to the agent | The agent works to a written definition of done instead of guessing at one |
 | **Verification Gates** | Gates declared in `.commandmate/verify.yaml` run through `verify` / `wait --verify` and return exit `0` / `20` / `21` | "Done" is what a verification run returned, not what the agent said |
 | **Evidence & Metrics** | The built-in work-evidence and scope gates, plus `verify history`, `task show` and `report metrics` | Commits, gate logs and numbers are left behind for the next decision |
-| **Skills Catalog** | Install and update official Skills per worktree, from the web UI or `commandmate skill` | The method is installed for the agent to read, not kept in someone's head |
+
+### Know which one needs you
+
+| Feature | What it does | Why it matters |
+|---------|-------------|----------------|
 | **Never miss a waiting agent** | A waiting agent shows up as a badge, a toast, the tab title, the PWA app badge and a push notification | You find out the moment an agent needs you, even away from the desk |
-| **Git Worktree Sessions** | One session per worktree, parallel execution | Multiple issues progress simultaneously without interference |
-| **Multi-Agent Support** | Choose Claude Code, Codex, Gemini CLI, Copilot, OpenCode, Antigravity, Command Code or local models per worktree | Pick the right agent for each task |
-| **Auto Yes Mode** | Agent runs without stopping for confirmations | Optional unattended mode for trusted workflows — review the Security section before enabling |
 | **Web UI (Desktop & Mobile)** | Full session control from any browser | Monitor and steer from your desk or your phone |
 | **Conversation view** | Switch a session's output between the raw terminal and a chat transcript — replies render in full, tool runs and approvals fold into chips, and a TUI dialog is answerable from the chat surface | Follow the run and answer it — from your desk or your phone — without reading the TUI |
+
+### Method as a system
+
+| Feature | What it does | Why it matters |
+|---------|-------------|----------------|
+| **Skills Catalog** | Install and update official Skills per worktree, from the web UI or `commandmate skill` | The method is installed for the agent to read, not kept in someone's head |
+| **Scheduled Execution** | Cron-based auto-run via CMATE.md | Daily reviews, nightly tests — agents work on a schedule |
+
+### Also
+
+| Feature | What it does | Why it matters |
+|---------|-------------|----------------|
 | **File Viewer & Markdown Editor** | Browse and edit worktree files in the browser | Review changes and update AI instructions without opening an IDE |
 | **Screenshot Instructions** | Attach images to your prompts | Snap a bug → "Fix this" — the agent sees the screenshot |
-| **Scheduled Execution** | Cron-based auto-run via CMATE.md | Daily reviews, nightly tests — agents work on a schedule |
 | **Token Authentication** | SHA-256 hashed token + HTTPS + rate limiting | Secure remote access — no credentials leaked, brute-force protected |
 
-### Supported agents
+---
+
+## Supported agents
 
 All eight are first-class. Each one gets the same treatment inside CommandMate — its own launch path, its own hook source and its own status detection — so the worktree session, the task contract, the verification gates and the evidence trail behave the same way whichever agent you pick.
 
 - **Claude Code**, **Codex**, **Gemini CLI**, **Copilot**, **Antigravity** — choose per worktree, per task.
 - **OpenCode** — the open-source terminal agent, driven through the same contract-and-gate path as the rest.
 - **Command Code** — driven the same way, its hooks and its transcript included.
-- **Local models** (`vibe-local`) — run the same loop against a model you host yourself.
+- **Local models** (`vibe-local`) — the same worktree session, contract and gates, against a model you host yourself.
 
 ---
 
-## Use Cases
+## What it does not do
+
+- It is a run, not a resident agent. Nothing loops forever, and nothing mutates without an explicit approve.
+- It does not read the code for you. Gates catch what your tests and checks catch.
+- Review by another agent is a step you add, not something the runner does for you.
+- Approvals still come to a person. Auto Yes is opt-in, time-boxed, and stops on the patterns you set.
+- It does not replace tmux, Git worktrees, your terminal, or your agent CLI. An OS reboot ends the processes; what survives is the record.
+
+---
+
+## Use cases
 
 | Scenario | How CommandMate helps |
 |----------|----------------------|
-| **Parallel issue development** | Run multiple issues in separate worktrees, each with its own agent session |
-| **Issue refinement** | Define an issue, let AI fill gaps, review before any code is written |
-| **Overnight execution** | Queue issues with scheduled execution — check progress in the morning |
-| **Mobile review** | Review AI-generated changes and steer direction from your phone |
-| **Visual bug fix** | Snap a UI bug on your phone, send it with "Fix this" |
+| **Several issues, one message** | The lead plans waves, hands out contracts, and merges only what the gates passed. You read one report. |
+| **Too many sessions to watch** | One list, one state per session, read from hooks. The waiting one floats up. |
+| **Away from the desk** | The waiting agent reaches your phone. Approve or reject there. |
+| **Review by a different agent** | Hand the diff to another session and get the verdict back in the lead's chat. |
+| **Overnight execution** | Scheduled runs with contracts and gates; read the record in the morning. |
+
+---
+
+## From vibe coding to Vibe Engineering.
+
+Vibe Engineering — the AI does the building; the system, not your expertise, guarantees the engineering.
+
+We do not make the AI smarter. We make the software-engineering ability its user needed into a system.
+The contract says what done means before the work starts, the gates decide it afterwards, and the
+method that produced both is installed as Skills rather than remembered by whoever happened to run it.
+
+[Concept](./docs/en/concept.md) is the canonical text: the Vision, the Mission, and how each
+implementation item maps to a feature.
+
+> The term "vibe engineering" was coined by Simon Willison (2025) —
+> <https://simonwillison.net/2025/Oct/7/vibe-engineering/>.
 
 ---
 
 ## Security
 
-Runs **100% locally**. No external server, no cloud relay, no account required. The only network traffic is Claude CLI's own API calls.
+Runs **100% locally**. No external server, no cloud relay, no account required. The only network traffic is the agent CLI's own API calls.
 
 - Fully open-source ([MIT License](./LICENSE))
 - Local database, local sessions
@@ -135,6 +252,7 @@ development machine or phone will already have.
 ```mermaid
 flowchart LR
     A["Browser / Phone"] -->|HTTP| B["CommandMate Server"]
+    L["Lead session\n(any agent)"] -->|"send --contract / ask / wait --verify"| B
     B --> C["Session Manager"]
     G["Task Contract\n.commandmate/tasks/*.yaml"] --> C
     C -->|"spawn / attach"| D["tmux sessions\n(per worktree)"]
@@ -486,8 +604,7 @@ The comparison that matters is not against other products; it is against the way
 
 <a id="issue-driven-development"></a>
 
-We do not make the AI smarter. We make the software-engineering ability its user needed into a system.
-That system is three things you can hand to any agent: the method, as installed Skills; the contract,
+The system is three things you can hand to any agent: the method, as installed Skills; the contract,
 declared before the work; the gates, which decide afterwards whether the work is done.
 
 ```

package/dist/cli/commands/ask.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ask.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/ask.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsVpC,wBAAgB,gBAAgB,IAAI,OAAO,CAoN1C"}
+{"version":3,"file":"ask.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/ask.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsVpC,wBAAgB,gBAAgB,IAAI,OAAO,CA6N1C"}

package/dist/cli/commands/ask.js

@@ -369,8 +369,17 @@ a decision about that session's guard rails, not part of asking it a question.
             // reads: the alias-to-id mapping and the roster's tool are the same
             // facts for all four requests, and asking twice is how two of them end
             // up addressing different sessions (Issue #1925).
-            const target = options.instance
-                ? await (0, instances_1.resolveInstanceTarget)(client, worktreeId, options.instance, options.agent)
+            //
+            // Issue #2479: `--agent` alone is resolved too, with the tool id as the
+            // selector — a tool id names that tool's primary instance (#868) unless
+            // the roster has a row by that id. `resolveInstanceTarget` hands back no
+            // instance for an undefined selector (send / respond / capture rely on
+            // that), and an instance-less `ask` sent to <tool> but waited on the
+            // worktree default: exit 21 while the default was not running, and the
+            // default's turn instead of <tool>'s while it was.
+            const selector = options.instance ?? options.agent;
+            const target = selector
+                ? await (0, instances_1.resolveInstanceTarget)(client, worktreeId, selector, options.agent)
                 : null;
             const agent = target ? target.cliToolId : options.agent;
             const instanceId = target?.instanceId;

package/dist/cli/commands/remote.d.ts

@@ -6,6 +6,8 @@
  *   commandmate remote status     # Provider / URL / expiry / pairing state
  *   commandmate remote stop       # close the door, keeping the server running
  *
+ *   commandmate remote --auth remote-only   # only the phone's route authenticates
+ *
  * ## What lives here rather than in a Provider (§6.2)
  *
  * Two things, and both for the same reason — they are decisions about an
@@ -20,6 +22,17 @@
  *     Provider would have to re-derive interactive-vs-not per Provider, and its
  *     answer would be invisible to the caller that has to honour `--yes`.
  *
+ * ## How far the token reaches (Issue #2489)
+ *
+ * `--auth all` (the default) authenticates every listener, which is what #1937
+ * shipped. `--auth remote-only` runs a SECOND loopback listener, points the
+ * Provider at that one alone, and exempts the original from authentication — so
+ * the phone still pairs and the PC in front of the machine keeps working. The
+ * exemption is decided by which listener a request arrived on, never by its
+ * source address: a Provider's upstream IS 127.0.0.1, so every IP- and
+ * header-based answer here fails open. See `src/lib/ws-server.ts`'s ingress
+ * section for the full argument.
+ *
  * ## What this command deliberately does not have
  *
  *  - **`--token`.** `remote` is the side that MINTS a token; one supplied from
@@ -35,6 +48,7 @@
 import { Command } from 'commander';
 import { ExitCode } from '../types';
 import type { RemoteOptions } from '../types';
+import { type RemoteAuthScope } from '../utils/remote-state';
 import { type ProviderCandidate, type RemoteProviderId } from '../../lib/remote';
 /** Default remote-session TTL. Follows `parseDuration`'s 1h-30d range (§5.1). */
 export declare const DEFAULT_REMOTE_EXPIRES = "8h";
@@ -73,12 +87,27 @@ export declare const PUBLIC_TUNNEL_PROVIDERS: readonly RemoteProviderId[];
  *    put here would be readable by the very agents CommandMate is driving
  *    (§7.2).
  *
+ *  - `CM_AUTH_SCOPE` — the `--auth` value (#2489). Not a secret and not a path:
+ *    the string `all` or `remote-only`, which is what `middleware.ts` and
+ *    `ws-server.ts` read to decide whether the local listener may skip the
+ *    token. Always exported, including for `all`, so the server is told what
+ *    was chosen rather than inferring it from a missing variable.
+ *
  * `tests/unit/cli/commands/remote-launch-env-1937.test.ts` holds the measured
  * set to this declaration in BOTH directions, the way
  * `agent-launch-plan-secrets-1933.test.ts` does for `prepareLaunch`. Adding a
  * key without adding it here goes red; so does removing one.
  */
-export declare const REMOTE_LAUNCH_ENV_KEYS: readonly ["CM_AUTH_TOKEN_HASH", "CM_AUTH_EXPIRE", "CM_REMOTE_PAIRING_FILE"];
+export declare const REMOTE_LAUNCH_ENV_KEYS: readonly ["CM_AUTH_TOKEN_HASH", "CM_AUTH_EXPIRE", "CM_REMOTE_PAIRING_FILE", "CM_AUTH_SCOPE"];
+/**
+ * The measured set for `--auth remote-only` (Issue #2489).
+ *
+ * One key more than {@link REMOTE_LAUNCH_ENV_KEYS}, and declared separately
+ * rather than as an "optional extra" so the exact-set measurement keeps working
+ * in BOTH directions for BOTH modes. A conditional key checked against a single
+ * list would be a list that describes neither mode.
+ */
+export declare const REMOTE_ONLY_LAUNCH_ENV_KEYS: readonly ["CM_AUTH_TOKEN_HASH", "CM_AUTH_EXPIRE", "CM_REMOTE_PAIRING_FILE", "CM_AUTH_SCOPE", "CM_REMOTE_INGRESS_PORT"];
 /** Inputs of {@link buildRemoteLaunchEnv}. */
 export interface RemoteLaunchEnvInput {
     /** SHA-256 of the session token. The token itself never reaches the env. */
@@ -87,6 +116,17 @@ export interface RemoteLaunchEnvInput {
     authExpire: string;
     /** Absolute path of the 0600 pairing handoff file. */
     pairingFilePath: string;
+    /** Issue #2489: how far authentication reaches. */
+    authScope: RemoteAuthScope;
+    /**
+     * Issue #2489: the loopback port the server opens for the Provider.
+     *
+     * Required when `authScope` is `remote-only` and meaningless otherwise — the
+     * server refuses `remote-only` without it and falls back to authenticating
+     * every listener, so passing one mode's value with the other mode's scope
+     * cannot silently produce a half-open server.
+     */
+    remoteIngressPort?: number;
 }
 /** Pairing state as reported by `remote status` (§5.4). */
 export type PairingState = 'unused' | 'consumed' | 'expired';
@@ -98,8 +138,8 @@ export type PairingState = 'unused' | 'consumed' | 'expired';
  * {@link REMOTE_LAUNCH_ENV_KEYS} — "what did remote add" is otherwise only
  * observable by diffing a global.
  *
- * @param input - Hash, expiry and handoff path
- * @returns The three variables, and nothing else
+ * @param input - Hash, expiry, handoff path and auth scope
+ * @returns Those variables, and nothing else
  */
 export declare function buildRemoteLaunchEnv(input: RemoteLaunchEnvInput): Record<string, string>;
 /**
@@ -128,6 +168,56 @@ export declare function applyRemoteLaunchEnv(env: Record<string, string>): () =>
  * @throws Error when the format is wrong or the value is out of range
  */
 export declare function parsePairingDuration(value: string): number;
+/**
+ * What the user may type after `--auth`, and the default when they type nothing.
+ *
+ * Issue #2489. `all` is the default deliberately: `remote-only` leaves every
+ * process on this machine — including the agents CommandMate itself runs in tmux
+ * — able to reach the API without a token, which is the same exposure as a
+ * CommandMate started without `--auth` at all, and weaker than `all`. Opting
+ * into that is the user's call to make, not a default to inherit.
+ */
+export declare const REMOTE_AUTH_SCOPES: readonly RemoteAuthScope[];
+/** Auth scope applied when `--auth` is not given (Issue #2489). */
+export declare const DEFAULT_REMOTE_AUTH_SCOPE: RemoteAuthScope;
+/**
+ * Where the `remote-only` ingress listener lives (Issue #2489).
+ *
+ * The literal loopback address, matching `REMOTE_INGRESS_BIND` in `server.ts`:
+ * both Providers dial `http://127.0.0.1:<port>`, and the listener must not be
+ * reachable from anywhere else.
+ */
+export declare const REMOTE_INGRESS_HOST = "127.0.0.1";
+/**
+ * Parse an `--auth` value.
+ *
+ * @param value - Raw flag value; undefined means the flag was not given
+ * @returns The scope to use
+ * @throws Error naming the valid values, for CONFIG_ERROR
+ */
+export declare function parseAuthScope(value: string | undefined): RemoteAuthScope;
+/**
+ * The bind address the server this session starts will actually listen on.
+ *
+ * Read through `loadEffectiveEnv()` rather than `process.env` because that is
+ * what `daemon.start()` hands the child: it layers `.env` OVER the exported
+ * environment, so a `CM_BIND=0.0.0.0` written in `~/.commandmate/.env` is
+ * invisible to `process.env` here and decisive for the server. Checking the
+ * wrong one is how this guard would pass while the thing it guards against
+ * happened anyway.
+ *
+ * This is the one place `remote` reads `CM_BIND`, and only in `remote-only`
+ * mode — §9.1's "remote neither reads nor writes CM_BIND" still holds for every
+ * other path, and `remote` never writes it.
+ *
+ * @returns The effective `CM_BIND`, defaulted the way `server.ts` defaults it
+ */
+export declare function resolveEffectiveBind(): string;
+/**
+ * @param bind - An effective `CM_BIND` value
+ * @returns true when nothing outside this machine can reach that address
+ */
+export declare function isLoopbackBind(bind: string): boolean;
 /** Outcome of applying the selection rule to a probe result. */
 export interface ProviderSelection {
     /** The Provider to use, when there is one. */

package/dist/cli/commands/remote.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,QAAQ,EAAmB,MAAM,UAAU,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAoB9C,OAAO,EAGL,KAAK,iBAAiB,EAEtB,KAAK,gBAAgB,EAEtB,MAAM,kBAAkB,CAAC;AAQ1B,iFAAiF;AACjF,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C,yEAAyE;AACzE,eAAO,MAAM,uBAAuB,QAAQ,CAAC;AAE7C,gFAAgF;AAChF,eAAO,MAAM,kBAAkB,QAAY,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,QAAsB,CAAC;AAEtD,0EAA0E;AAC1E,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAK9E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,gBAAgB,EAAyB,CAAC;AAEzF;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,sBAAsB,6EAIzB,CAAC;AAEX,8CAA8C;AAC9C,MAAM,WAAW,oBAAoB;IACnC,4EAA4E;IAC5E,aAAa,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,2DAA2D;AAC3D,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAMxF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,IAAI,CAY5E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAgB1D;AAED,gEAAgE;AAChE,MAAM,WAAW,iBAAiB;IAChC,8CAA8C;IAC9C,SAAS,CAAC,EAAE,iBAAiB,CAAC;IAC9B,8DAA8D;IAC9D,KAAK,CAAC,EAAE;QACN,QAAQ,EAAE,QAAQ,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,gFAAgF;QAChF,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,SAAS,iBAAiB,EAAE,EACxC,SAAS,CAAC,EAAE,MAAM,GACjB,iBAAiB,CA6CnB;AAoID;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,CAmL3E;AA0BD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjE;AA8BD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,cAAc,EAAE,OAAO,EACvB,gBAAgB,EAAE,MAAM,EACxB,GAAG,GAAE,MAAmB,GACvB,YAAY,CAGd;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAMlD;AAkDD;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,CA2E/E;AAWD;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,CAkD7E;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC,CA8Bf;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAoB7C"}
+{"version":3,"file":"remote.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/remote.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,QAAQ,EAAmB,MAAM,UAAU,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAW9C,OAAO,EAKL,KAAK,eAAe,EAErB,MAAM,uBAAuB,CAAC;AAI/B,OAAO,EAIL,KAAK,iBAAiB,EAEtB,KAAK,gBAAgB,EAEtB,MAAM,kBAAkB,CAAC;AAQ1B,iFAAiF;AACjF,eAAO,MAAM,sBAAsB,OAAO,CAAC;AAE3C,yEAAyE;AACzE,eAAO,MAAM,uBAAuB,QAAQ,CAAC;AAE7C,gFAAgF;AAChF,eAAO,MAAM,kBAAkB,QAAY,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,QAAsB,CAAC;AAEtD,0EAA0E;AAC1E,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAK9E,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,gBAAgB,EAAyB,CAAC;AAEzF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,sBAAsB,8FAKzB,CAAC;AAEX;;;;;;;GAOG;AACH,eAAO,MAAM,2BAA2B,wHAG9B,CAAC;AAEX,8CAA8C;AAC9C,MAAM,WAAW,oBAAoB;IACnC,4EAA4E;IAC5E,aAAa,EAAE,MAAM,CAAC;IACtB,0EAA0E;IAC1E,UAAU,EAAE,MAAM,CAAC;IACnB,sDAAsD;IACtD,eAAe,EAAE,MAAM,CAAC;IACxB,mDAAmD;IACnD,SAAS,EAAE,eAAe,CAAC;IAC3B;;;;;;;OAOG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,2DAA2D;AAC3D,MAAM,MAAM,YAAY,GAAG,QAAQ,GAAG,UAAU,GAAG,SAAS,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,oBAAoB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAWxF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,MAAM,IAAI,CAY5E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAgB1D;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB,EAAE,SAAS,eAAe,EAA2B,CAAC;AAErF,mEAAmE;AACnE,eAAO,MAAM,yBAAyB,EAAE,eAAuB,CAAC;AAEhE;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,cAAc,CAAC;AAa/C;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,eAAe,CAUzE;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,oBAAoB,IAAI,MAAM,CAE7C;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEpD;AAED,gEAAgE;AAChE,MAAM,WAAW,iBAAiB;IAChC,8CAA8C;IAC9C,SAAS,CAAC,EAAE,iBAAiB,CAAC;IAC9B,8DAA8D;IAC9D,KAAK,CAAC,EAAE;QACN,QAAQ,EAAE,QAAQ,CAAC;QACnB,OAAO,EAAE,MAAM,CAAC;QAChB,gFAAgF;QAChF,OAAO,EAAE,MAAM,EAAE,CAAC;KACnB,CAAC;CACH;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,SAAS,iBAAiB,EAAE,EACxC,SAAS,CAAC,EAAE,MAAM,GACjB,iBAAiB,CA6CnB;AAoID;;;;;GAKG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,CA2Q3E;AA0BD;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjE;AA8BD;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAChC,cAAc,EAAE,OAAO,EACvB,gBAAgB,EAAE,MAAM,EACxB,GAAG,GAAE,MAAmB,GACvB,YAAY,CAGd;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAMlD;AAkDD;;;;;;;;;;;GAWG;AACH,wBAAsB,eAAe,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,CAmF/E;AAkCD;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,QAAQ,CAAC,CAkD7E;AAED;;;;;;;;;GASG;AACH,wBAAsB,aAAa,CACjC,MAAM,EAAE,MAAM,GAAG,SAAS,EAC1B,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC,CA8Bf;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,IAAI,OAAO,CAwB7C"}