@porte/cli 0.1.1 → 0.1.3

package/README.md

@@ -1,25 +1,78 @@
-# @porte/cli
+# Porte
 
-Run your local Grok sessions from your phone. This is the daemon that pairs a Mac with [useporte.dev](https://useporte.dev); Grok, your repos, and every transcript stay on the Mac.
+Porte - means door in French - is a secure remote interface for your local Grok conversations.
+
+Manage the same Grok threads and repos from your phone while they continue to run on your laptop. Porte does not replace the TUI, and each account can access only its own machines.
 
 ## Install
 
 ```sh
 npm i -g @porte/cli
+porte pair
+```
+
+Or hand it to your agent: `Fetch and execute the instructions from https://useporte.dev/agent-setup/prompt.md to set up Porte on this machine.`
+
+## How it works
+
+1. Run the daemon on the machine where you already use Grok.
+2. Sign in on your phone and pair that machine.
+3. Open a conversation — or start a new one in a known repo.
+4. Read the transcript. Prompt. Approve or deny.
+
+```
+Phone (your account)  →  Porte  →  your paired machine
+                                              │
+                                         Grok agent
+                                              │
+                                    local conversations + repos
+```
+
+## What Porte handles
+
+Porte relays remote actions while your machine keeps the Grok runtime and all local data.
+
+| ☁️ Us                                  | 💻 Your machine           |
+| -------------------------------------- | ------------------------- |
+| App account + pairing                  | `grok.com` login, spend   |
+| Conversation titles (id, cwd, updated) | Repos, files, transcripts |
+| Live relay of prompts and approvals    | The Grok process          |
+
+## Safety
+
+Remote Grok is the same Grok you already run.
+
+- Starts in **that project’s directory**
+- Inherits your `AGENTS.md`, rules, hooks, sandbox, and ask/deny
+- No `--always-approve`. No extra filesystem or network power
+- A click on the TUI is still a click on the phone. Deny still denies
+
+## Development
+
+```sh
+pnpm install
+pnpm dev                                          # web on :3000; `pnpm dev up` connects a local host through the tunnel
+pnpm turbo run lint typecheck test:unit test:integration
+pnpm --filter @porte/web test:design              # Playwright pictures; Mac only, run before a commit
 ```
 
-Needs Node 22 or newer, and the `grok` CLI on the path and signed in.
+Cloudflare types are generated (`worker-configuration.d.ts`, gitignored). Turbo runs `cf-typegen` before lint, typecheck, tests, and build, so a fresh checkout sees what a dev does.
+
+### Releasing the CLI
 
-## Use
+`apps/host` publishes as `@porte/cli`. A release is a version bump on `main`:
 
 ```sh
-porte pair   # link this Mac to your account: copy the code, approve it in the browser
-porte up     # connect, so the phone can reach it
-porte unpair # end the pairing
+pnpm --filter @porte/cli version patch --no-git-checks   # bumps apps/host/package.json only
+git commit -am "release(cli): x.y.z" && git push
 ```
 
-## What it does not do
+`.github/workflows/publish-cli.yaml` lints, typechecks, tests, builds, and publishes with provenance through npm trusted publishing (`pnpm publish --provenance`, no token). A push that leaves the version alone publishes nothing. The npm page shows this README, copied at pack time.
+
+### Deploying the web app
+
+Cloudflare Workers Builds is connected to this repository: every push to `main` builds and deploys the web app. Nothing is deployed by hand.
 
-Porte adds no permissions. Remote Grok starts in the project's directory and inherits your `AGENTS.md`, hooks, sandbox, and ask/deny rules. Deny on the phone is deny on the Mac.
+## License
 
-Source and issues: [github.com/alexander-zuev/porte](https://github.com/alexander-zuev/porte). Apache-2.0.
+[Apache License 2.0](LICENSE).

package/dist/{client-CpzDWkFF.js → client-BwrMf7hy.js}

@@ -5058,7 +5058,13 @@ const ConversationFailurePayloadSchema = discriminatedUnion("_tag", [
 		message: string().min(1)
 	})
 ]);
-uuidv7().brand();
+//#endregion
+//#region ../../packages/core/src/identity/identity.ts
+/**
+* These schemas define identifiers that cross Porte process boundaries.
+* Each brand prevents accidental use of a different identifier.
+*/
+const HostIdSchema = uuidv7().brand();
 uuidv7().brand();
 uuidv7().brand();
 uuidv7().brand();
@@ -5640,11 +5646,11 @@ var ConfigurationNotFoundError = class extends h(CONFIGURATION_NOT_FOUND_ERROR)
 const HOST_OFFLINE_ERROR = "HostOfflineError";
 const HOST_ALREADY_PAIRED_ERROR = "HostAlreadyPairedError";
 const WORKSPACE_NOT_ALLOWED_ERROR = "WorkspaceNotAllowedError";
-/** The path is not one the Mac reported, so the daemon will not open it. */
+/** The path is not one the machine reported, so the daemon will not open it. */
 var WorkspaceNotAllowedError = class extends h(WORKSPACE_NOT_ALLOWED_ERROR) {
 	constructor() {
 		super({
-			message: "That repository is not available on this Mac",
+			message: "That repository is not available on this machine",
 			classification: "terminal"
 		});
 	}
@@ -5778,17 +5784,17 @@ const HostPlatformSchema = _enum([
 //#endregion
 //#region ../../packages/core/src/host/account-host.ts
 /**
-* Which Mac an account owns, if any.
+* Which machine an account owns, if any.
 *
-* Durable facts only. Nothing here says whether the Mac can be reached or what
+* Durable facts only. Nothing here says whether the machine can be reached or what
 * is on it, because the database cannot see either; the relay answers both.
 * Loading and error are absent for the same reason: they describe a request,
 * not the account.
 */
 /**
-* A paired Mac, as the database knows it.
+* A paired machine, as the database knows it.
 *
-* There is no availability here. Whether a Mac is reachable is a live question
+* There is no availability here. Whether a machine is reachable is a live question
 * the relay answers, and a read that guessed at it would be a second version of
 * a fact it cannot see. `lastSeenAt` is null until a daemon has announced
 * itself, because approving a grant is not an observation of one.
@@ -5796,7 +5802,11 @@ const HostPlatformSchema = _enum([
 const PairedHostSchema = object({
 	name: string().min(1),
 	platform: HostPlatformSchema
-}).extend({ lastSeenAt: IsoDateTimeSchema.nullable() });
+}).extend({
+	/** Names the pairing's relay object; a re-pair after unpair gets a new one. */
+	id: HostIdSchema,
+	lastSeenAt: IsoDateTimeSchema.nullable()
+});
 discriminatedUnion("state", [
 	object({ state: literal("unpaired") }),
 	object({
@@ -5833,7 +5843,7 @@ const ProblemDetailsSchema = looseObject({
 	title: string(),
 	/**
 	* Safe human-readable explanation for this occurrence; clients must not parse it.
-	* @example "Porte is not connected on the paired Mac."
+	* @example "Porte is not connected on the paired machine."
 	*/
 	detail: string().optional(),
 	/**
@@ -6155,6 +6165,8 @@ const PORTE_CLI_CLIENT_ID = "porte-cli";
 * serves it cannot drift; the route asserts it against the generated tree.
 */
 const PAIRING_CODE_PATH = "/api/pair/code";
+/** Where the daemon ends its own pairing: DELETE with its bearer token. */
+const HOST_PAIRING_PATH = "/api/host/pairing";
 /** RFC 8628 fixes this value; the token request is invalid without it. */
 const DEVICE_CODE_GRANT_TYPE = "urn:ietf:params:oauth:grant-type:device_code";
 /**
@@ -6223,7 +6235,7 @@ function formatPairingCode(code) {
 /**
 * Where the code was asked for, judged against where it is being answered.
 *
-* The server compares, not the screen. Both halves normally happen on one Mac,
+* The server compares, not the screen. Both halves normally happen on one machine,
 * so `elsewhere` is the whole signal: someone else's machine asked for a code
 * you are about to approve.
 */
@@ -6705,4 +6717,4 @@ async function sendJsonRpcFrame(write) {
 	if (sent.isErr()) throw sent.error;
 }
 //#endregion
-export { INTERNAL_SERVER_ERROR as $, ProblemDetailsSchema as A, PermissionNotFoundError as B, DeviceTokenErrorSchema as C, PORTE_CLI_CLIENT_ID as D, PAIRING_CODE_PATH as E, AgentUnresponsiveError as F, makeConversationSummary as G, ConversationEventSchema as H, ConfigurationNotFoundError as I, IsoDateTimeSchema as J, ConversationIdSchema as K, ConversationBusyError as L, isClassifiedError as M, isDomainError as N, createLogger as O, WorkspaceNotAllowedError as P, turnIdFor as Q, ConversationNotFoundError as R, DeviceCodeResponseSchema as S, DeviceTokenResponseSchema as T, ToolViewSchema as U, TurnNotFoundError as V, ConversationCursorSchema as W, PermissionIdSchema as X, MessageIdSchema as Y, ToolCallIdSchema as Z, readJsonRpcIncoming as _, url as _t, HOST_APPLICATION_ERROR_CODE as a, _enum as at, DEVICE_CODE_GRANT_TYPE as b, HOST_CONVERSATION_SUBPROTOCOL as c, email as ct, JSON_RPC_ERROR_CODES as d, literal as dt, InternalServerError as et, JsonRpcReadError as f, number as ft, jsonRpcNotification as g, unknown as gt, jsonRpcError as h, string as ht, HostControlMethods as i, h as it, HostPlatformSchema as j, setLogSink as k, HostRequestIdSchema as l, httpUrl as lt, handleJsonRpcRequest as m, record as mt, sendJsonRpcFrame as n, CODING_AGENT_UNAVAILABLE_ERROR as nt, HOST_APPLICATION_ERROR_MESSAGE as o, array as ot, JsonRpcTextSchema as p, object as pt, ElicitationIdSchema as q, HostConversationMethods as r, CodingAgentUnavailableError as rt, HOST_CONTROL_SUBPROTOCOL as s, discriminatedUnion as st, JsonRpcSendError as t, ServiceUnavailableError as tt, SequenceNumberSchema as u, json as ut, readJsonRpcTextFrame as v, DeviceTokenRequestSchema as w, DeviceCodeRequestSchema as x, formatPairingCode as y, ElicitationNotFoundError as z };
+export { turnIdFor as $, setLogSink as A, ElicitationNotFoundError as B, DeviceTokenErrorSchema as C, PAIRING_CODE_PATH as D, HOST_PAIRING_PATH as E, WorkspaceNotAllowedError as F, ConversationCursorSchema as G, TurnNotFoundError as H, AgentUnresponsiveError as I, ElicitationIdSchema as J, makeConversationSummary as K, ConfigurationNotFoundError as L, HostPlatformSchema as M, isClassifiedError as N, PORTE_CLI_CLIENT_ID as O, isDomainError as P, ToolCallIdSchema as Q, ConversationBusyError as R, DeviceCodeResponseSchema as S, DeviceTokenResponseSchema as T, ConversationEventSchema as U, PermissionNotFoundError as V, ToolViewSchema as W, MessageIdSchema as X, IsoDateTimeSchema as Y, PermissionIdSchema as Z, readJsonRpcIncoming as _, unknown as _t, HOST_APPLICATION_ERROR_CODE as a, h as at, DEVICE_CODE_GRANT_TYPE as b, HOST_CONVERSATION_SUBPROTOCOL as c, discriminatedUnion as ct, JSON_RPC_ERROR_CODES as d, json as dt, INTERNAL_SERVER_ERROR as et, JsonRpcReadError as f, literal as ft, jsonRpcNotification as g, string as gt, jsonRpcError as h, record as ht, HostControlMethods as i, CodingAgentUnavailableError as it, ProblemDetailsSchema as j, createLogger as k, HostRequestIdSchema as l, email as lt, handleJsonRpcRequest as m, object as mt, sendJsonRpcFrame as n, ServiceUnavailableError as nt, HOST_APPLICATION_ERROR_MESSAGE as o, _enum as ot, JsonRpcTextSchema as p, number as pt, ConversationIdSchema as q, HostConversationMethods as r, CODING_AGENT_UNAVAILABLE_ERROR as rt, HOST_CONTROL_SUBPROTOCOL as s, array as st, JsonRpcSendError as t, InternalServerError as tt, SequenceNumberSchema as u, httpUrl as ut, readJsonRpcTextFrame as v, url as vt, DeviceTokenRequestSchema as w, DeviceCodeRequestSchema as x, formatPairingCode as y, ConversationNotFoundError as z };

package/dist/main.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { k as setLogSink } from "./client-CpzDWkFF.js";
+import { A as setLogSink } from "./client-BwrMf7hy.js";
 //#region src/main.ts
 const major = Number(process.versions.node.split(".")[0]);
 if (Number.isNaN(major) || major < 22) {
@@ -11,7 +11,7 @@ setLogSink((_level, line) => {
 });
 const verbose = process.argv.includes("--verbose") || process.argv.includes("-v");
 process.env.LOG_LEVEL ??= verbose ? "DEBUG" : "WARN";
-const { run } = await import("./run-cli-Djt_v7Px.js");
+const { run } = await import("./run-cli-CEPB1b8j.js");
 const code = await run(process.argv.slice(2), {
 	stdout: process.stdout,
 	stderr: process.stderr,

package/dist/{run-cli-Djt_v7Px.js → run-cli-CEPB1b8j.js}

@@ -1,4 +1,4 @@
-import { $ as INTERNAL_SERVER_ERROR, A as ProblemDetailsSchema, B as PermissionNotFoundError, C as DeviceTokenErrorSchema, D as PORTE_CLI_CLIENT_ID, E as PAIRING_CODE_PATH, F as AgentUnresponsiveError, G as makeConversationSummary, H as ConversationEventSchema, I as ConfigurationNotFoundError, J as IsoDateTimeSchema, K as ConversationIdSchema, L as ConversationBusyError, M as isClassifiedError, N as isDomainError, O as createLogger, P as WorkspaceNotAllowedError, Q as turnIdFor, R as ConversationNotFoundError, S as DeviceCodeResponseSchema, T as DeviceTokenResponseSchema, U as ToolViewSchema, V as TurnNotFoundError, W as ConversationCursorSchema, X as PermissionIdSchema, Y as MessageIdSchema, Z as ToolCallIdSchema, _ as readJsonRpcIncoming, _t as url, a as HOST_APPLICATION_ERROR_CODE, at as _enum, b as DEVICE_CODE_GRANT_TYPE, c as HOST_CONVERSATION_SUBPROTOCOL, ct as email, d as JSON_RPC_ERROR_CODES, dt as literal, et as InternalServerError, f as JsonRpcReadError, ft as number, g as jsonRpcNotification, gt as unknown, h as jsonRpcError, ht as string, i as HostControlMethods, it as h, j as HostPlatformSchema, l as HostRequestIdSchema, lt as httpUrl, m as handleJsonRpcRequest, mt as record, n as sendJsonRpcFrame, nt as CODING_AGENT_UNAVAILABLE_ERROR, o as HOST_APPLICATION_ERROR_MESSAGE, ot as array, p as JsonRpcTextSchema, pt as object, q as ElicitationIdSchema, r as HostConversationMethods, rt as CodingAgentUnavailableError, s as HOST_CONTROL_SUBPROTOCOL, st as discriminatedUnion, t as JsonRpcSendError, tt as ServiceUnavailableError, u as SequenceNumberSchema, ut as json, v as readJsonRpcTextFrame, w as DeviceTokenRequestSchema, x as DeviceCodeRequestSchema, y as formatPairingCode, z as ElicitationNotFoundError } from "./client-CpzDWkFF.js";
+import { $ as turnIdFor, B as ElicitationNotFoundError, C as DeviceTokenErrorSchema, D as PAIRING_CODE_PATH, E as HOST_PAIRING_PATH, F as WorkspaceNotAllowedError, G as ConversationCursorSchema, H as TurnNotFoundError, I as AgentUnresponsiveError, J as ElicitationIdSchema, K as makeConversationSummary, L as ConfigurationNotFoundError, M as HostPlatformSchema, N as isClassifiedError, O as PORTE_CLI_CLIENT_ID, P as isDomainError, Q as ToolCallIdSchema, R as ConversationBusyError, S as DeviceCodeResponseSchema, T as DeviceTokenResponseSchema, U as ConversationEventSchema, V as PermissionNotFoundError, W as ToolViewSchema, X as MessageIdSchema, Y as IsoDateTimeSchema, Z as PermissionIdSchema, _ as readJsonRpcIncoming, _t as unknown, a as HOST_APPLICATION_ERROR_CODE, at as h, b as DEVICE_CODE_GRANT_TYPE, c as HOST_CONVERSATION_SUBPROTOCOL, ct as discriminatedUnion, d as JSON_RPC_ERROR_CODES, dt as json, et as INTERNAL_SERVER_ERROR, f as JsonRpcReadError, ft as literal, g as jsonRpcNotification, gt as string, h as jsonRpcError, ht as record, i as HostControlMethods, it as CodingAgentUnavailableError, j as ProblemDetailsSchema, k as createLogger, l as HostRequestIdSchema, lt as email, m as handleJsonRpcRequest, mt as object, n as sendJsonRpcFrame, nt as ServiceUnavailableError, o as HOST_APPLICATION_ERROR_MESSAGE, ot as _enum, p as JsonRpcTextSchema, pt as number, q as ConversationIdSchema, r as HostConversationMethods, rt as CODING_AGENT_UNAVAILABLE_ERROR, s as HOST_CONTROL_SUBPROTOCOL, st as array, t as JsonRpcSendError, tt as InternalServerError, u as SequenceNumberSchema, ut as httpUrl, v as readJsonRpcTextFrame, vt as url, w as DeviceTokenRequestSchema, x as DeviceCodeRequestSchema, y as formatPairingCode, z as ConversationNotFoundError } from "./client-BwrMf7hy.js";
 import { homedir, hostname } from "node:os";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { execFileSync, spawn } from "node:child_process";
@@ -98,7 +98,7 @@ var UnsupportedPlatformError = class extends h("UnsupportedPlatformError") {
 	}
 };
 /**
-* What this Mac calls itself.
+* What this machine calls itself.
 *
 * `platform` stays the runtime's own token, so what is stored is what Node
 * reported. Turning `darwin` into `macOS` is the reader's job, and spelling it
@@ -168,7 +168,7 @@ var WebSocketHandlerError = class extends h("WebSocketHandlerError") {
 //#endregion
 //#region src/entrypoints/cli/version.ts
 /** Package version. Source is `package.json`. */
-const VERSION = "0.1.1";
+const VERSION = "0.1.3";
 //#endregion
 //#region src/entrypoints/cli/cli-error.ts
 /** Bad arguments or missing required flags. */
@@ -199,7 +199,7 @@ function formatError(error) {
 	if (error instanceof ConfigError || error instanceof UnsupportedPlatformError) body = `Error (ECONFIG): Porte configuration is invalid.\n${error.message}`;
 	else if (error instanceof HostNotPairedError) body = error.message;
 	else if (error instanceof WebSocketHandlerError || error instanceof JsonRpcSendError) body = "Error (ERELAY): host connection stopped. Restart `porte up`.";
-	else if (error instanceof WebSocketHandshakeRefused) body = error.status === 401 || error.status === 403 ? `Error (EAUTH): ${error.message} Run \`porte pair\` to pair this Mac again.` : `Error (ERELAY): ${error.message}`;
+	else if (error instanceof WebSocketHandshakeRefused) body = error.status === 401 || error.status === 403 ? `Error (EAUTH): ${error.message} Run \`porte pair\` to pair this machine again.` : `Error (ERELAY): ${error.message}`;
 	else if (error instanceof WebSocketProtocolClose) body = `Error (ERELAY): ${error.message}`;
 	else if (error instanceof PairingError) body = `Error (EPAIR): ${error.message} Run \`porte pair\` to try again.`;
 	else body = `Error (ECRED): ${error.message}`;
@@ -340,7 +340,7 @@ function reportUnexpectedCliError(stderr, cause) {
 //#endregion
 //#region src/application/commands/pair-host.ts
 /**
-* Pair this Mac with a Porte account.
+* Pair this machine with a Porte account.
 *
 * The daemon asks for a code, shows it, and waits. Approval happens on the
 * person's phone, so this machine never handles a password and the credential
@@ -538,13 +538,30 @@ var DeviceAuthorizationClient = class {
 		return fromRefusal(refusal.data.error);
 	}
 	/**
-	* End the pairing.
+	* End the pairing on the server, before the credential is dropped locally.
 	*
-	* Stubbed: the route it needs does not exist yet, so unpairing currently only
-	* clears the local credential. Wiring the request is a change to this method.
+	* A refused token means the browser already ended it, which is the state
+	* asked for. Anything else stays an error, so the caller keeps the credential
+	* and can try again: a pairing the server still holds is what nothing else can clean up.
 	*/
-	revoke(_token) {
-		return Promise.resolve();
+	async revoke(token) {
+		let response;
+		try {
+			response = await fetch(new URL(HOST_PAIRING_PATH, this.baseUrl), {
+				method: "DELETE",
+				headers: { Authorization: `Bearer ${token}` }
+			});
+		} catch (cause) {
+			throw new PairingError({
+				reason: "unreachable",
+				cause
+			});
+		}
+		if (response.ok || response.status === 401 || response.status === 403) return;
+		throw new PairingError({
+			reason: "unexpected",
+			cause: response.status
+		});
 	}
 	/**
 	* Ask who the new token belongs to.
@@ -708,7 +725,7 @@ async function runPairCommand(input) {
 		onPrompt: (prompt) => {
 			const shown = formatPairingCode(prompt.userCode);
 			const waiting = `Waiting for approval — the code expires in ${String(Math.round(prompt.expiresInSeconds / 60))} minutes.  ${WAITING_EMOJI}`;
-			output.title("Pair this Mac with Porte", PAIR_EMOJI);
+			output.title("Pair this machine with Porte", PAIR_EMOJI);
 			if (!interactive) {
 				output.raw(`First copy your pairing code:  ${code(shown)}`);
 				output.raw(`Then open ${url(prompt.verificationUri)} in your browser.`);
@@ -754,7 +771,7 @@ async function runPairCommand(input) {
 	const machine = strong(describeThisMachine().name);
 	output.done(account === null ? `Paired ${machine} with Porte` : `Paired ${machine} with ${strong(account)} on Porte`);
 	output.blank();
-	output.raw(`  Run ${code("porte up")} to control this Mac's Grok conversations from anywhere`);
+	output.raw(`  Run ${code("porte up")} to control this machine's Grok conversations from anywhere`);
 	output.note("Expires in 7 days if it never connects");
 	return 0;
 }
@@ -772,8 +789,8 @@ Options:
   -v, --verbose    Write debug logs to stderr
 
 Commands:
-  pair             Link this Mac to your Porte account
-  unpair           End this Mac's pairing
+  pair             Link this machine to your Porte account
+  unpair           End this machine's pairing
   up               Connect this host to Porte
 
 Examples:
@@ -784,7 +801,7 @@ Examples:
 const PAIR_HELP = `Usage:
   porte pair
 
-Link this Mac to your Porte account. Prints a code to approve in any browser,
+Link this machine to your Porte account. Prints a code to approve in any browser,
 then waits. Run this once; \`porte up\` uses what it stores.
 
 Options:
@@ -798,7 +815,7 @@ Environment:
 const UNPAIR_HELP = `Usage:
   porte unpair
 
-End this Mac's pairing. Porte stops accepting it, and the local credential is
+End this machine's pairing. Porte stops accepting it, and the local credential is
 deleted. Run \`porte pair\` to connect it again.
 
 Options:
@@ -4149,12 +4166,12 @@ async function runUnpairCommand(input) {
 	const output = createOutput(input.stderr);
 	const stored = await resources.credentials.read();
 	if (stored === null) {
-		output.done("This Mac is not paired.");
+		output.done("This machine is not paired.");
 		return 0;
 	}
 	await resources.authorizer.revoke(stored.token);
 	await resources.credentials.clear();
-	output.done(`Unpaired this Mac from ${output.emphasis.strong(new URL(stored.baseUrl).host)}`);
+	output.done(`Unpaired this machine from ${output.emphasis.strong(new URL(stored.baseUrl).host)}`);
 	return 0;
 }
 //#endregion

package/package.json

@@ -1,8 +1,8 @@
 {
   "$schema": "https://www.schemastore.org/package.json",
   "name": "@porte/cli",
-  "version": "0.1.1",
-  "description": "Run your local Grok sessions from your phone. The daemon that pairs a Mac with useporte.dev.",
+  "version": "0.1.3",
+  "description": "Run your local Grok sessions from your phone. The daemon that pairs a machine with useporte.dev.",
   "keywords": [
     "acp",
     "agent",
@@ -51,6 +51,9 @@
   },
   "scripts": {
     "dev": "tsx src/main.ts",
+    "dev:pair": "PORTE_URL=https://tunnel.useporte.dev PORTE_DATA_DIRECTORY=$HOME/.porte-dev tsx src/main.ts pair",
+    "dev:up": "PORTE_URL=https://tunnel.useporte.dev PORTE_DATA_DIRECTORY=$HOME/.porte-dev tsx src/main.ts up",
+    "dev:unpair": "PORTE_URL=https://tunnel.useporte.dev PORTE_DATA_DIRECTORY=$HOME/.porte-dev tsx src/main.ts unpair",
     "build": "tsdown",
     "typecheck": "tsc --noEmit",
     "lint": "oxlint .",