teamclaws 1.0.0 → 1.0.2

package/README.md

@@ -12,6 +12,63 @@ package.
   GNU/Linux distribution with glibc 2.28 or newer
 - x64 or ARM64
 
+## Installation
+
+Install the published CLI:
+
+```text
+npm install -g teamclaws@latest
+teamclaws --version
+```
+
+To install a downloaded release tarball:
+
+```text
+npm install -g ./teamclaws-1.0.1.tgz
+teamclaws --version
+```
+
+GitHub source ZIPs must be built before use; they are not npm installers.
+
+## Agent onboarding
+
+> Install teamclaws@latest, read its agent skills, and help me connect to my cloud workspace.
+
+Start with [teamclaws-onboard](skills/teamclaws-onboard/SKILL.md). For a global
+installation, `npm root -g` locates the package root; read
+`teamclaws/skills/teamclaws-onboard/SKILL.md` beneath it. The package contains one
+shared workflow for login, alias-based user-selected pairing (including a single
+workspace), additional pairings, project transfer, and optional public/private
+live hosting. Login and pairing mechanics remain in their respective skills;
+[teamclaws-project](skills/teamclaws-project/SKILL.md) covers project work through
+the existing paired shell. Status-only requests do not start onboarding.
+
+### Onboarding output contract
+
+Existing event names and schema version remain unchanged. The
+`login_browser_required` event provides the safe `url`, a `label` of
+`Sign in to TeamClaws`, and `account_guidance`. Display these immediately while
+login keeps running. Signed-out `auth_status` includes the non-executing
+`login_command: "teamclaws login --json"`; status never starts device authorization.
+
+`servers list` requests `GET /api/cli/v1/servers/?include_inventory=1&include_description=1`. Updated
+brokers return `servers` and `workspace_count`: the count of all non-deleted
+owned and eligible shared workspaces, including those without a hostname yet.
+Individual server entries retain aliases, stable IDs, status and `pairing_ready`.
+When supported, they also include the server description. Older brokers may
+omit descriptions; nonempty descriptions appear under each readable list entry.
+Older brokers may omit the count; the CLI reports it as null and never infers
+an empty account from an empty filtered list.
+
+The `servers_list` event adds `workspace_count` and `discovery_state`:
+`no_workspaces` only for a verified count of zero, `ready` when any listed
+workspace is pairing-ready, `not_ready` when workspaces exist but none is ready,
+and `unknown` for an empty legacy response without a count. Discovery errors
+remain error events. A verified empty account uses https://teamclaws.com/app/ to
+purchase a workspace. Existing owners whose machines are being prepared do not
+need another purchase. Targetless pairing requires explicit selection even for
+one result; agents present aliases and pass only user-selected stable IDs.
+
 ## Commands
 
 ```text
@@ -23,6 +80,7 @@ npx teamclaws servers list
 npx teamclaws pair status <server-identifier-or-canonical-workspace-address>
 npx teamclaws pair
 npx teamclaws pair <server-identifier-or-canonical-workspace-address> [--no-open]
+npx teamclaws shell <target> --command <text> [--json]
 npx teamclaws chat start <target> --message <text>
 npx teamclaws chat send <target> --session-id <uuid> --message <text>
 npx teamclaws chat watch <target> --session-id <uuid> --request-id <uuid>
@@ -31,6 +89,13 @@ npx teamclaws chat watch <target> --session-id <uuid> --request-id <uuid>
 Human-readable output is the default. Add `--json` for the strict, versioned,
 newline-delimited JSON event stream intended for automation.
 
+Pairing (including explicit targets), server listing, pair status, chat, and shell
+require a valid TeamClaws CLI account login. Run `teamclaws login` first. The CLI
+refreshes and verifies that login before contacting the workspace or requesting
+pairing approval. Missing or invalid authentication exits with code 3 in both
+human and JSON modes. Help, version, login, auth status, and logout remain
+available. Saved workspace credentials are preserved when login is required.
+
 Pairing is broad privileged delegation to the approved workspace. The client
 does not request or select scopes, profiles, capability bundles, roles, user
 types, or permission labels. TeamClaws, Clawgate, and host policy determine the
@@ -40,8 +105,8 @@ The client never accepts a model or harness access token. An agent that already
 discovered a workspace passes only the selected stable server identifier to the
 `pair` command.
 
-`pair status` is side-effect free: it reads only the matching protected local
-credential, performs at most one direct workspace verification with a
+After account authentication, `pair status` reads the matching protected local
+workspace credential, performs at most one direct workspace verification with a
 five-second timeout, reports the result, and stops. It never starts pairing or
 loads external-chat resources.
 
@@ -54,6 +119,25 @@ Python helper. Use `--client-request-id <uuid>` to safely repeat an uncertain
 create request, and use the watch cursors printed in JSON events to resume
 monitoring without creating another turn.
 
+## Host shell commands
+
+`teamclaws shell <target> --command <text> [--json]` uses an existing saved
+pairing to execute the exact command text on the workspace host. Quote the
+command as one local shell argument; quotes, pipes and newlines inside that
+argument are preserved. Each request starts in the executing account's home
+directory. The command does not log in, pair, or load chat capabilities.
+
+Normal mode forwards stdout and stderr without adding text. JSON mode emits one
+object with `stdout`, `stderr`, and `exit_code`. Both modes return the remote
+process exit code. HTTP/authentication/transport errors use the existing CLI
+error output and failure codes.
+
+The client sends one POST to `/teamclaws-admin/api/shell/` with
+`Content-Type: text/plain; charset=utf-8`, never follows redirects, and never
+retries execution. The shell path has no command or HTTP operation deadline,
+command-size limit, or response/output-size limit. A network failure can leave the
+execution outcome unknown; inspect the host before deciding to run it again.
+
 ## Local storage
 
 Login credentials are stored in the private TeamClaws user directory. Completed
@@ -63,13 +147,6 @@ directories use mode `0700` and files use mode `0600`; Windows uses
 inheritance-disabled access-control entries limited to the current user and the
 Windows system account.
 
-## Development
-
-```text
-npm ci
-npm run verify
-```
-
 The package is licensed under the PolyForm Shield License 1.0.0. Paid service
 access is enforced by TeamClaws servers, not by the client license.
 
@@ -79,7 +156,7 @@ Run `teamclaws chat capabilities <target> [--json]` with an existing saved
 workspace pairing. It reads the workspace capabilities endpoint with a shared
 120-second budget, attempts lasting at most 15 seconds, and pauses of up to five
 seconds between retryable failures or inventories with no model choices. It does not
-log in, pair, or start a chat. Without a saved pairing it makes no request.
+log in, pair, or start a chat. Without a saved pairing it makes no workspace request.
 
 JSON output is one `chat_capabilities` event with `schema_version: 1`,
 `status: "success"`, `source: "refresh"`, the safe workspace ID/origin, and
@@ -104,4 +181,79 @@ The timestamp describes snapshot generation, not an authorization lease. The
 existing refresh endpoint does not supply a generation timestamp. Chat requests
 still validate current authorization and selection; explicitly refresh if a
 selection is no longer available. No chat mutation is automatically replayed by
-this command. Pair status retains its one-request, terminal behavior.
+this command. Pair status retains its single workspace verification and terminal behavior.
+
+## CLI updates
+
+Every command invocation checks `https://registry.npmjs.org/teamclaws` before
+command dispatch, including help and version. The check has a 1.5-second total
+deadline, a 2 MiB metadata limit, no redirects, no credentials, and no persistent
+cache. Registry failure or malformed metadata silently leaves ordinary commands
+available. Nothing is installed automatically.
+
+When a newer published stable `latest` release exists, stderr receives:
+
+```text
+Version 1.2.0 Available starting on 09/12/2026. Use command teamclaws update to update as soon as possible.
+```
+
+With `--json`, stderr receives one newline-delimited `update_available` JSON
+object containing `version`, `published_at`, `available_date`, `update_command`,
+and `message`. Agents should capture both streams. Existing stdout results,
+shell result objects, event streams, help/version text, and command exit codes
+retain their contracts. Raw shell stderr follows the advisory unchanged; callers
+requiring only remote stderr must separate the first advisory line. Long-running
+commands receive the notice once at startup, not on every streamed event.
+
+Run `teamclaws update` (or `teamclaws update --json`) explicitly to install.
+The command does not require login. It supports only a verified npm global
+installation matching the running package and npm's reported global prefix.
+Local, linked, npx, other package-manager installations, mismatched prefixes,
+and layouts without npm beside the running Node executable are unsupported;
+update those through their original package manager. No prefix is guessed and
+no automatic privilege elevation occurs.
+
+The installer uses Node to launch npm's JavaScript entrypoint with literal
+arguments on Windows, Linux, and macOS. It pins the official registry, package,
+and checked version, disables lifecycle scripts, and verifies the installed
+package version afterward. It never accesses the `.teamclaws` credential tree:
+login and workspace credentials remain separate from the installed package.
+Installation failure returns nonzero; an interrupted npm install may require
+repair through npm. The updater does not promise transactional rollback.
+
+Release selection uses `dist-tags.latest`, the matching `versions` manifest,
+and `time[version]` in official registry metadata. Prereleases, deprecated
+releases, missing publication records, future timestamps, and invalid package
+or tarball identity are rejected. The displayed date is the publication date in
+UTC, formatted `MM/DD/YYYY`, not the metadata modification date or a private
+commit date. Semantic precedence ignores build metadata and never downgrades
+an equal/newer candidate; a stable version supersedes its same-core prerelease.
+See [npm distribution tags](https://docs.npmjs.com/cli/v11/commands/npm-dist-tag/),
+[npm publication time fields](https://docs.npmjs.com/cli/v11/commands/npm-view/),
+[Semantic Versioning](https://semver.org/), and
+[npm installation layouts](https://docs.npmjs.com/cli/v11/configuring-npm/folders/).
+
+## Find conversations started on this computer
+
+Run `teamclaws chat list <target> --json` to recover locally recorded session and
+latest request identifiers for a verified pairing. Login and direct pairing
+verification are required; listing does not fetch capabilities, create a chat,
+send a message, poll a request, or call a remote history endpoint.
+
+The `chat_sessions_list` event has `status: success`, `source: local`, the
+selected `workspace`, and `sessions` containing `session_id`, `request_id`,
+`owner_conversation_url`, `revision`, `response_cursor`, and `updated_at`.
+Use the existing send/watch commands with those identifiers. For watch, pass
+revision as `--known-revision` and cursor as `--after-response-message-id`.
+Every subsequent remote operation retains its normal authorization checks.
+
+References are saved separately from credentials in private files under
+`~/.teamclaws/chat-references/`, partitioned by workspace and paired device.
+No message text, tokens, headers, or transcripts are saved. Empty results mean
+no locally recorded conversations; other computers' chats and old unsaved
+references are not discoverable. Device identity is not included in list output.
+
+If recording fails after a remote response, `chat_reference_recovery` preserves
+the validated identifiers and cursors, followed by `chat_reference_storage_failed`
+(exit 9). Retain those identifiers and resume with watch; never automatically
+repeat the remote mutation. Existing login and pairing credentials are unchanged.

package/dist/app.js

@@ -6,7 +6,9 @@ import { TeamClawsError, safeError } from "./errors.js";
 import { ExternalChatClient, } from "./external-chat.js";
 import { Output } from "./output.js";
 import { PairingClient } from "./pairing.js";
+import { runShell, shellFetch } from "./shell.js";
 import { CredentialStore } from "./storage.js";
+import { installRelease } from "./update.js";
 import { parsePairingTarget } from "./validation.js";
 export async function run(arguments_, dependencies = {}, signal) {
     let parsed;
@@ -31,6 +33,40 @@ export async function run(arguments_, dependencies = {}, signal) {
         stdout.write(`${PACKAGE_VERSION}\n`);
         return 0;
     }
+    if (parsed.action === "update") {
+        const checked = dependencies.releaseCheck;
+        let status;
+        let message;
+        let code = 0;
+        if (!checked || checked.status === "unavailable") {
+            status = "unavailable";
+            message =
+                "Could not verify an official stable release. No update was installed. Try teamclaws update again later.";
+            code = 1;
+        }
+        else if (checked.status === "current") {
+            status = "current";
+            message = "No newer official stable TeamClaws release is available.";
+        }
+        else {
+            try {
+                await (dependencies.installer ?? installRelease)(checked.release, signal);
+                status = "updated";
+                message = `Updated TeamClaws to ${checked.release.version}.`;
+            }
+            catch {
+                status = "failed";
+                message =
+                    "Update failed. Requires the active npm global installation with write permission and npm beside Node. Local, linked, npx, and managed installs must use their original package manager. No privilege elevation was attempted. Check the installed version before retrying.";
+                code = 1;
+            }
+        }
+        if (parsed.json)
+            stdout.write(`${JSON.stringify({ schema_version: 1, event: "update_result", status, message })}\n`);
+        else
+            (code ? stderr : stdout).write(`${message}\n`);
+        return code;
+    }
     const store = dependencies.store ?? new CredentialStore();
     const auth = new AuthService({
         store,
@@ -67,16 +103,27 @@ export async function run(arguments_, dependencies = {}, signal) {
             case "logout":
                 await auth.logout(signal);
                 return 0;
+        }
+        const token = await auth.requireAccessToken(parsed.action === "pair"
+            ? "Authenticate in the TeamClaws CLI with `teamclaws login` before making a pairing request."
+            : "Authenticate in the TeamClaws CLI with `teamclaws login` before running this command.", signal);
+        switch (parsed.action) {
+            case "shell": {
+                const result = await runShell(store, dependencies.fetcher ?? shellFetch, parsePairingTarget(parsed.target), parsed.command, signal);
+                if (parsed.json)
+                    stdout.write(`${JSON.stringify(result)}\n`);
+                else {
+                    stdout.write(result.stdout);
+                    stderr.write(result.stderr);
+                }
+                return result.exit_code;
+            }
             case "servers_list": {
-                const token = await auth.accessToken(signal);
-                if (!token)
-                    throw loginRequired();
-                const servers = await broker.servers(token, signal);
-                output.servers(servers);
+                const inventory = await broker.servers(token, signal);
+                output.servers(inventory.servers, inventory.workspace_count);
                 return 0;
             }
             case "pair": {
-                const token = await auth.accessToken(signal);
                 const target = parsed.target
                     ? parsePairingTarget(parsed.target)
                     : await discoverTarget(broker, token, parsed.json, output, dependencies.io, signal);
@@ -88,6 +135,8 @@ export async function run(arguments_, dependencies = {}, signal) {
                 const status = await pairing.status(parsePairingTarget(parsed.target), signal);
                 return status === "paired" ? 0 : status === "unreachable" ? 5 : 1;
             }
+            case "chat_list":
+                return await externalChat.list(parsePairingTarget(parsed.target), signal);
             case "chat_capabilities":
                 return await externalChat.capabilities(parsePairingTarget(parsed.target), signal);
             case "chat_start":
@@ -105,12 +154,34 @@ export async function run(arguments_, dependencies = {}, signal) {
     }
 }
 export function parseArguments(arguments_) {
+    if (arguments_[0] === "shell") {
+        const target = requiredPositional(arguments_, 1);
+        let command;
+        let json = false;
+        for (let index = 2; index < arguments_.length; index += 1) {
+            const option = arguments_[index];
+            if (option === "--command" && command === undefined) {
+                command = arguments_[++index];
+                if (command === undefined || command.length === 0)
+                    throw usageError();
+            }
+            else if (option === "--json" && !json)
+                json = true;
+            else
+                throw usageError();
+        }
+        if (command === undefined)
+            throw usageError();
+        return { action: "shell", target, command, json };
+    }
     const json = arguments_.includes("--json");
     const args = arguments_.filter((argument) => argument !== "--json");
     if (args.length === 0 || args[0] === "--help" || args[0] === "-h")
         return { action: "help", json };
     if (args[0] === "--version" || args[0] === "-v")
         return { action: "version", json };
+    if (args[0] === "update" && args.length === 1)
+        return { action: "update", json };
     if (args[0] === "login") {
         if (args.length === 1)
             return { action: "login", json };
@@ -145,6 +216,9 @@ export function parseArguments(arguments_) {
         const target = positional[0];
         return { action: "pair", json, ...(target ? { target } : {}), noOpen };
     }
+    if (args[0] === "chat" && args[1] === "list" && args.length === 3) {
+        return { action: "chat_list", json, target: requiredPositional(args, 2) };
+    }
     if (args[0] === "chat" && args[1] === "capabilities" && args.length === 3) {
         return { action: "chat_capabilities", json, target: args[2] };
     }
@@ -275,18 +349,16 @@ function nonNegativeInteger(value) {
     return parsed;
 }
 async function discoverTarget(broker, token, json, output, io, signal) {
-    if (!token) {
-        throw new TeamClawsError("login_or_server_required", "Sign in or provide a stable server identifier or canonical workspace address.", { exitCode: 4 });
-    }
-    const servers = (await broker.servers(token, signal)).filter((server) => server.pairing_ready);
+    const inventory = await broker.servers(token, signal);
+    const servers = inventory.servers.filter((server) => server.pairing_ready);
     if (servers.length === 0) {
-        throw new TeamClawsError("no_pairing_ready_workspaces", "No pairing-ready TeamClaws workspaces are available.", { exitCode: 4 });
+        throw new TeamClawsError("no_pairing_ready_workspaces", inventory.workspace_count === 0
+            ? "No TeamClaws workspaces are available to this account. Purchase a workspace at https://teamclaws.com/app/."
+            : "No pairing-ready TeamClaws workspaces are available. Check existing workspaces at https://teamclaws.com/app/; this does not mean you need to purchase another.", { exitCode: 4 });
     }
-    if (servers.length === 1)
-        return { server_id: servers[0].server_id };
     const interactive = io?.interactive ?? (process.stdin.isTTY && process.stdout.isTTY);
     if (json || !interactive) {
-        throw new TeamClawsError("server_selection_required", "More than one workspace is available. Provide the stable server identifier.", { exitCode: 4 });
+        throw new TeamClawsError("server_selection_required", "Choose a workspace by alias from `teamclaws servers list`, then provide its stable server identifier after the user agrees to pair.", { exitCode: 4 });
     }
     output.servers(servers);
     const selected = await promptForServer(servers, io?.input ?? process.stdin, io?.stdout ?? process.stdout);
@@ -311,17 +383,11 @@ async function promptForServer(servers, input, output) {
         terminal.close();
     }
 }
-function loginRequired() {
-    return new TeamClawsError("login_required", "Sign in to TeamClaws first.", {
-        exitCode: 3,
-    });
-}
 function usageError() {
     return new TeamClawsError("invalid_command", "Run `teamclaws --help` for supported commands.", {
         exitCode: 2,
     });
 }
 export function helpText() {
-    return `TeamClaws ${PACKAGE_VERSION}\n\nUsage:\n  teamclaws login [email] [--json]\n  teamclaws auth status [--json]\n  teamclaws logout [--json]\n  teamclaws servers list [--json]\n  teamclaws pair status <server-identifier-or-canonical-workspace-address> [--json]\n  teamclaws pair [server-identifier-or-canonical-workspace-address] [--no-open] [--json]\n  teamclaws chat capabilities <target> [--json]\n  teamclaws chat start <target> --message <text> [selection options] [--json]\n  teamclaws chat send <target> --session-id <uuid> --message <text> [--json]\n  teamclaws chat watch <target> --session-id <uuid> --request-id <uuid> [resume cursors] [--json]\n\nPair status performs one bounded direct verification and stops. Pairing grants the standard host-issued credential. Chat commands use that credential directly against the selected workspace.\n`;
+    return `TeamClaws ${PACKAGE_VERSION}\n\nUsage:\n  teamclaws update [--json]\n  teamclaws shell <target> --command <text> [--json]\n  teamclaws login [email] [--json]\n  teamclaws auth status [--json]\n  teamclaws logout [--json]\n  teamclaws servers list [--json]\n  teamclaws pair status <server-identifier-or-canonical-workspace-address> [--json]\n  teamclaws pair [server-identifier-or-canonical-workspace-address] [--no-open] [--json]\n  teamclaws chat list <target> [--json]\n  teamclaws chat capabilities <target> [--json]\n  teamclaws chat start <target> --message <text> [selection options] [--json]\n  teamclaws chat send <target> --session-id <uuid> --message <text> [--json]\n  teamclaws chat watch <target> --session-id <uuid> --request-id <uuid> [resume cursors] [--json]\n\nPair status performs one bounded direct verification and stops. Pairing grants the standard host-issued credential. Chat commands use that credential directly against the selected workspace.\n`;
 }
-//# sourceMappingURL=app.js.map

package/dist/auth.js

@@ -76,6 +76,14 @@ export class AuthService {
         const active = await this.ensureActive(credential, signal);
         return active.access_token;
     }
+    async requireAccessToken(message, signal) {
+        const token = await this.accessToken(signal);
+        if (!token) {
+            throw new TeamClawsError("login_required", message, { exitCode: 3 });
+        }
+        await this.fetchIdentity(token, signal);
+        return token;
+    }
     async ensureActive(credential, signal) {
         const expiresAt = Date.parse(credential.expires_at);
         if (expiresAt - this.now() > 30_000)
@@ -171,7 +179,7 @@ export class AuthService {
             ...(signal ? { signal } : {}),
         });
         if (response.status === 401) {
-            throw new TeamClawsError("invalid_authentication", "The TeamClaws login is no longer valid.", {
+            throw new TeamClawsError("invalid_authentication", "The TeamClaws login is no longer valid. Run `teamclaws login` to authenticate.", {
                 exitCode: 3,
             });
         }
@@ -299,7 +307,10 @@ function oauthError(status, body) {
     if (error) {
         code = error === "invalid_grant" ? "invalid_authentication" : error;
     }
-    return new TeamClawsError(code, "TeamClaws rejected the login request.", {
+    const message = error === "invalid_grant"
+        ? "The TeamClaws login is no longer valid. Run `teamclaws login` to authenticate."
+        : "TeamClaws rejected the login request.";
+    return new TeamClawsError(code, message, {
         retryable: status >= 500,
         exitCode: 3,
     });
@@ -327,4 +338,3 @@ async function waitFor(milliseconds, signal) {
         signal?.addEventListener("abort", onAbort, { once: true });
     });
 }
-//# sourceMappingURL=auth.js.map

package/dist/broker.js

@@ -3,7 +3,7 @@ import { randomUUID } from "node:crypto";
 import { API_BASE, CLIENT_NAME, CONTRACT_VERSION, MAX_CLIENT_LABEL_LENGTH, MAX_DEVICE_NAME_LENGTH, PACKAGE_VERSION, } from "./constants.js";
 import { TeamClawsError } from "./errors.js";
 import { errorFromResponse, requestJson } from "./http.js";
-import { parsePendingPairing, parseServersResponse } from "./validation.js";
+import { parsePendingPairing, parseWorkspaceInventory } from "./validation.js";
 export class BrokerClient {
     fetcher;
     deviceName;
@@ -15,19 +15,19 @@ export class BrokerClient {
         return normalizedDeviceName(this.deviceName());
     }
     async servers(accessToken, signal) {
-        const response = await requestJson(this.fetcher, `${API_BASE}servers/`, {
+        const response = await requestJson(this.fetcher, `${API_BASE}servers/?include_inventory=1&include_description=1`, {
             headers: requestHeaders(accessToken),
             ...(signal ? { signal } : {}),
         });
         if (response.status === 401) {
-            throw new TeamClawsError("invalid_authentication", "The TeamClaws login is no longer valid.", {
+            throw new TeamClawsError("invalid_authentication", "The TeamClaws login is no longer valid. Run `teamclaws login` to authenticate.", {
                 exitCode: 3,
             });
         }
         if (response.status < 200 || response.status >= 300) {
             throw errorFromResponse(response, "server_discovery_failed");
         }
-        return parseServersResponse(response.body);
+        return parseWorkspaceInventory(response.body);
     }
     async startPairing(target, accessToken, signal) {
         const request = pairingStartRequest(target, this.currentDeviceName());
@@ -76,4 +76,3 @@ function requestHeaders(accessToken) {
         headers.Authorization = `Bearer ${accessToken}`;
     return headers;
 }
-//# sourceMappingURL=broker.js.map

package/dist/browser.js

@@ -30,4 +30,3 @@ export function browserCommand(url, platform = process.platform) {
         return { executable: "xdg-open", arguments: [url] };
     return undefined;
 }
-//# sourceMappingURL=browser.js.map

package/dist/cli.js

@@ -1,14 +1,13 @@
 #!/usr/bin/env node
-import { run } from "./app.js";
+import { runCli } from "./startup.js";
 const controller = new AbortController();
 const interrupt = () => controller.abort();
 process.once("SIGINT", interrupt);
 process.once("SIGTERM", interrupt);
 try {
-    process.exitCode = await run(process.argv.slice(2), {}, controller.signal);
+    process.exitCode = await runCli(process.argv.slice(2), {}, controller.signal);
 }
 finally {
     process.removeListener("SIGINT", interrupt);
     process.removeListener("SIGTERM", interrupt);
 }
-//# sourceMappingURL=cli.js.map

package/dist/constants.js

@@ -1,5 +1,5 @@
 export const PACKAGE_NAME = "teamclaws";
-export const PACKAGE_VERSION = "1.0.0";
+export const PACKAGE_VERSION = "1.0.2";
 export const CLIENT_NAME = "teamclaws-cli";
 export const CONTRACT_VERSION = 1;
 export const OUTPUT_SCHEMA_VERSION = 1;
@@ -18,4 +18,3 @@ export const DEFAULT_RESPONSE_LIMIT_BYTES = 1_048_576;
 export const MAX_DEVICE_NAME_LENGTH = 120;
 export const MAX_CLIENT_LABEL_LENGTH = 120;
 export const MAX_ERROR_MESSAGE_LENGTH = 300;
-//# sourceMappingURL=constants.js.map

package/dist/errors.js

@@ -17,4 +17,3 @@ export function safeError(error) {
         return error;
     return new TeamClawsError("unexpected_error", "TeamClaws could not complete the command. Try again.", { exitCode: 1 });
 }
-//# sourceMappingURL=errors.js.map

package/dist/external-chat.js

@@ -2,7 +2,7 @@ import { randomUUID } from "node:crypto";
 import { PACKAGE_VERSION } from "./constants.js";
 import { TeamClawsError } from "./errors.js";
 import { errorFromResponse, requestJson, } from "./http.js";
-import { isObject, normalizeUuid, parseVerifiedWorkspace, requireHttpsUrl, requireInteger, requireString, } from "./validation.js";
+import { isObject, normalizeUuid, parseVerifiedWorkspace, parseVerifiedDevice, requireHttpsUrl, requireInteger, requireString, } from "./validation.js";
 const REQUIRED_SCOPES = new Set([
     "external_chat:capabilities:read",
     "external_chat:sessions:create",
@@ -167,6 +167,37 @@ export class ExternalChatClient {
         const requestId = validUuid(options.requestId);
         return this.poll(context, { requestId, sessionId }, options.knownRevision, options.responseCursor, signal);
     }
+    async list(target, signal) {
+        const credential = await this.store.findWorkspace(target);
+        if (!credential)
+            throw new TeamClawsError("re_pair_required", "No saved pairing was found for this workspace. Pair it first.", { exitCode: 3 });
+        const response = await this.request(`${credential.origin}/teamclaws-admin/api/device-pairings/me/`, bearer(credential), {}, [200], signal);
+        parseVerifiedDevice(response.body, credential.device_id);
+        requirePairingScopes(response.body);
+        this.output.chatSessionsList(credential, await this.store.listConversations(credential));
+        return 0;
+    }
+    async record(context, state, responseCursor) {
+        try {
+            await this.store.upsertConversation(context.credential, {
+                server_id: context.credential.server_id,
+                origin: context.credential.origin,
+                device_id: context.credential.device_id,
+                session_id: state.sessionId,
+                request_id: state.requestId,
+                owner_conversation_url: state.ownerUrl,
+                revision: state.revision,
+                response_cursor: responseCursor,
+                updated_at: new Date().toISOString(),
+            });
+        }
+        catch (error) {
+            // The remote operation already happened. Preserve its safe references even
+            // if local storage is unavailable; never replay the mutation.
+            this.output.chatReferenceRecovery(state.sessionId, state.requestId, state.ownerUrl, state.revision, responseCursor);
+            throw error;
+        }
+    }
     async context(target, signal, starting = false) {
         const credential = await this.store.findWorkspace(target);
         if (!credential) {
@@ -238,6 +269,7 @@ export class ExternalChatClient {
             }
             knownRevision = state.revision;
             responseCursor = Math.max(responseCursor, state.responseCursor, ...seenMessageIds);
+            await this.record(context, state, responseCursor);
             if (TERMINAL_STATUSES.has(state.status))
                 break;
             if (!PENDING_STATUSES.has(state.status))
@@ -341,8 +373,7 @@ function parseCapabilities(value, inventoryOnly = false) {
             throw invalidChatResponse();
         }
         const id = requireString(provider.id, "provider identifier", 120);
-        if (provider.models.length > 128)
-            throw invalidChatResponse();
+        // Catalogs grow independently of the CLI; HTTP response bytes are bounded.
         const models = provider.models.map((model) => {
             if (!isObject(model))
                 throw invalidChatResponse();
@@ -567,4 +598,3 @@ async function waitFor(milliseconds, signal) {
         signal?.addEventListener("abort", onAbort, { once: true });
     });
 }
-//# sourceMappingURL=external-chat.js.map

package/dist/http.js

@@ -2,16 +2,22 @@ import { DEFAULT_CONNECT_TIMEOUT_MS, DEFAULT_RESPONSE_LIMIT_BYTES, MAX_ERROR_MES
 import { TeamClawsError } from "./errors.js";
 import { isObject } from "./validation.js";
 export async function requestJson(fetcher, url, options = {}) {
-    const timeout = AbortSignal.timeout(options.timeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS);
-    const signal = options.signal
+    const timeout = options.timeoutMs === null
+        ? undefined
+        : AbortSignal.timeout(options.timeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS);
+    const signal = timeout && options.signal
         ? AbortSignal.any([timeout, options.signal])
-        : timeout;
+        : (timeout ?? options.signal);
     const headers = new Headers({
         Accept: "application/json",
         ...options.headers,
     });
     let body;
-    if (options.form) {
+    if (options.textBody !== undefined) {
+        headers.set("Content-Type", "text/plain; charset=utf-8");
+        body = options.textBody;
+    }
+    else if (options.form) {
         headers.set("Content-Type", "application/x-www-form-urlencoded");
         body = options.form.toString();
     }
@@ -26,11 +32,11 @@ export async function requestJson(fetcher, url, options = {}) {
             headers,
             ...(body === undefined ? {} : { body }),
             redirect: "error",
-            signal,
+            ...(signal ? { signal } : {}),
         });
     }
     catch (error) {
-        if (signal.aborted) {
+        if (signal?.aborted) {
             throw new TeamClawsError("network_timeout", "TeamClaws did not respond in time.", {
                 retryable: true,
                 exitCode: 5,
@@ -43,7 +49,9 @@ export async function requestJson(fetcher, url, options = {}) {
         });
     }
     const contentLength = Number(response.headers.get("content-length") ?? 0);
-    const limit = options.responseLimitBytes ?? DEFAULT_RESPONSE_LIMIT_BYTES;
+    const limit = options.responseLimitBytes === null
+        ? Infinity
+        : (options.responseLimitBytes ?? DEFAULT_RESPONSE_LIMIT_BYTES);
     if (contentLength > limit) {
         throw new TeamClawsError("response_too_large", "TeamClaws returned an oversized response.", {
             exitCode: 9,
@@ -104,4 +112,3 @@ function safeProtocolString(value, fallback, maxLength) {
         return fallback;
     return value;
 }
-//# sourceMappingURL=http.js.map