codeden 0.3.0 → 0.4.1

package/dist/{main-BAX1sPiD.js → main-f5CBW7t4.js}

@@ -1,16 +1,18 @@
 import { n as __require, r as __toESM, t as __commonJSMin } from "./rolldown-runtime-DegdyBIC.js";
-import { $ as ExportAutomationsQuery, $n as datetime, $t as TriageIssueRequest, A as SessionFileQuery, An as SessionOptions, At as UiClientMessage, B as ImageTestRequest, Bn as InboxItemKind, Bt as UpdateInstallRequest, C as isElectronRuntime, Cn as GitPushRequest, Ct as SecretKey, D as CODEDEN_VERSION, Dn as TerminalClientMessage, Dt as StartSessionRequest, E as wrapper_default, En as SpeechSummaryRequest, Et as SetSecretRequest, F as ListConflictsQuery, Fn as Project, Ft as LOCAL_STT_SAMPLE_RATE, G as BrowserNavigateRequest, Gn as AgentConfigLocator, Gt as NOTICE_BATCH_CODE, H as BrowserClientMessage, Hn as AgentConfigDeleteQuery, Ht as compareVersions, I as ListNoticesQuery, In as sortProjects, It as LocalSttModelParams, J as BrowserViewportRequest, Jn as McpServerTarget, Jt as GithubIssue, K as BrowserNewTabRequest, Kn as AgentConfigWriteRequest, Kt as CreateGithubIssueRequest, L as ResolveConflictRequest, Ln as DEFAULT_VISION_PATH, Lt as SttQuery, M as RunnerToServerMessage, Mn as ConflictDecision, Mt as HealthResponse, N as ServerLock, Nn as StartedBy, Nt as agentEventToNewEvent, O as UsageQuery, On as TerminalQuery, Ot as SteerRequest, P as ArchiveSessionRequest, Pn as WorkKey, Pt as Settings, Q as DuplicateAutomationRequest, Qn as ReasoningEffort, Qt as MergePrRequest, R as RoleMessageRequest, Rn as FactoryLimits, Rt as TtsRequest, S as acquireInstallLock, Sn as GitCommitRequest, St as RespondRequest, T as import_websocket_server, Tn as SessionResult, Tt as SessionStartMeta, U as BrowserDevServerRequest, Un as AgentConfigDiffRequest, Ut as isNewerVersion, V as summarizeActivity, Vn as messageFrom, Vt as UpdateStatus, W as BrowserHistoryRequest, Wn as AgentConfigListQuery, Wt as ConflictRecord, X as AUTOMATION_IMPORT_LIMITS, Xn as AutonomyLevel, Xt as GithubListQuery, Y as BrowserWsQuery, Yn as McpServerUpsertRequest, Yt as GithubLabelRequest, Z as AutomationImportSource, Zn as ProviderId, Zt as GithubPr, _ as importClaudeSdkFrom, _n as TriagePolicy, _r as unknown, _t as FileWriteRequest, a as Hono, an as FactoryTuning, ar as discriminatedUnion, at as ListAutomationRunsQuery, b as runNpm, bn as DiffScope, br as safeParse$1, bt as ReorderProjectsRequest, c as serve, cn as ReviewVerdict, cr as literal, ct as SetAutomationEnabledRequest, d as createImageEngineRegistry, dn as Artifact, dr as object, dt as TriageReport, en as githubPrId, er as _enum, et as ImportAutomationsRequest, f as IMAGE_ASPECT_RATIOS, fn as Automation, fr as optional, ft as UpcomingRunsQuery, g as CLAUDE_SDK_VERSION, gn as AutomationTrigger, gr as union$1, gt as FileReadQuery, h as claudeSdkSource, hn as AutomationRun, hr as string, ht as CreateProjectRequest, i as killTree$1, in as FactoryTriageRequest, ir as custom, it as CreateAutomationRequest, j as RunnerLock, jn as ProjectConfigFile, jt as UpdateProjectRequest, k as UsageSettings, kn as RunnerCommandResults, kt as ThreadItemsQuery, l as upgradeWebSocket, ln as SetAutonomyModeRequest, lr as looseObject, lt as StarterSetRequest, m as ImageGenerationError, mn as AutomationGuards, mr as record, mt as UpdateAutomationRequest, n as readLock, nn as DiscoveryArea, nr as array, nt as AutomationGuardsPatch, o as tryDecodeURIComponent, on as KillSwitchRequest, or as int, ot as ListAutomationsQuery, p as resolveImageOutput, pn as AutomationAction, pr as preprocess, pt as UpdateAutomationProjectSettingsRequest, q as BrowserOpenRequest, qn as McpServerDiffRequest, qt as GithubCommentRequest, r as isAlive, rn as FactoryCandidate, rr as boolean, rt as AutomationProjectRequest, s as bufferToFormData, sn as PutVisionRequest, sr as intersection, st as RunAutomationRequest, tn as parseGithubPrId, tr as _null, tt as AutomationFileFrontmatter, u as ImageEngineRegistry, un as isFactoryMode, ur as number, ut as TriageDecisionRequest, v as installClaudeSdk, vn as Session, vr as ZodError, vt as ListInboxQuery, w as ownNodeEnv, wn as RestoreFilesRequest, wt as SendMessageRequest, x as resolveNpm, xn as EditQueuedMessageRequest, xr as prettifyError, xt as ResolveInboxRequest, y as isClaudeSdkInstalled, yn as SessionStatus, yr as toJSONSchema, yt as ListSessionsQuery, z as UpdateSessionRequest, zn as InboxItem, zt as AppPointer } from "./runner-DGomZl80.js";
+import { $ as BrowserNavigateRequest, $n as AgentConfigLocator, $t as NOTICE_BATCH_CODE, A as SessionFileQuery, An as GitCommitRequest, At as RespondRequest, B as NetworkStatus, Bn as ConflictDecision, Bt as HealthResponse, C as isElectronRuntime, Cn as AutomationRun, Cr as string, Ct as CreateProjectRequest, D as CODEDEN_VERSION, Dn as SessionStatus, Dr as toJSONSchema, Dt as ListSessionsQuery, E as wrapper_default, En as Session, Er as ZodError, Et as ListInboxQuery, F as ListConflictsQuery, Fn as TerminalClientMessage, Ft as StartSessionRequest, G as SetNetworkPasswordResponse, Gn as DEFAULT_VISION_PATH, Gt as SttQuery, H as RemoteAccessFile, Hn as WorkKey, Ht as Settings, I as ListNoticesQuery, In as TerminalQuery, It as SteerRequest, J as ImageTestRequest, Jn as InboxItemKind, Jt as UpdateInstallRequest, K as SignInRequest, Kn as FactoryLimits, Kt as TtsRequest, L as ResolveConflictRequest, Ln as RunnerCommandResults, Lt as ThreadItemsQuery, M as RunnerToServerMessage, Mn as RestoreFilesRequest, Mt as SendMessageRequest, N as ServerLock, Nn as SessionResult, Nt as SessionStartMeta, O as UsageQuery, On as DiffScope, Or as safeParse$1, Ot as ReorderProjectsRequest, P as ArchiveSessionRequest, Pn as SpeechSummaryRequest, Pt as SetSecretRequest, Q as BrowserHistoryRequest, Qn as AgentConfigListQuery, Qt as ConflictRecord, R as RoleMessageRequest, Rn as SessionOptions, Rt as UiClientMessage, S as acquireInstallLock, Sn as AutomationGuards, Sr as record, St as UpdateAutomationRequest, T as import_websocket_server, Tn as TriagePolicy, Tr as unknown, Tt as FileWriteRequest, U as SetNetworkAccessRequest, Un as Project, Ut as LOCAL_STT_SAMPLE_RATE, V as PASSWORD_RULE_TEXT, Vn as StartedBy, Vt as agentEventToNewEvent, W as SetNetworkPasswordRequest, Wn as sortProjects, Wt as LocalSttModelParams, X as BrowserClientMessage, Xn as AgentConfigDeleteQuery, Xt as compareVersions, Y as summarizeActivity, Yn as messageFrom, Yt as UpdateStatus, Z as BrowserDevServerRequest, Zn as AgentConfigDiffRequest, Zt as isNewerVersion, _ as importClaudeSdkFrom, _n as SetAutonomyModeRequest, _r as looseObject, _t as StarterSetRequest, a as Hono, an as GithubPr, ar as ProviderId, at as AutomationImportSource, b as runNpm, bn as Automation, br as optional, bt as UpcomingRunsQuery, c as createAdaptorServer, cn as githubPrId, cr as _enum, ct as ImportAutomationsRequest, d as createImageEngineRegistry, dn as FactoryCandidate, dr as boolean, dt as AutomationProjectRequest, en as CreateGithubIssueRequest, er as AgentConfigWriteRequest, et as BrowserNewTabRequest, f as IMAGE_ASPECT_RATIOS, fn as FactoryTriageRequest, fr as custom, ft as CreateAutomationRequest, g as CLAUDE_SDK_VERSION, gn as ReviewVerdict, gr as literal, gt as SetAutomationEnabledRequest, h as claudeSdkSource, hn as PutVisionRequest, hr as intersection, ht as RunAutomationRequest, i as killTree$1, in as GithubListQuery, ir as AutonomyLevel, it as AUTOMATION_IMPORT_LIMITS, j as RunnerLock, jn as GitPushRequest, jt as SecretKey, k as UsageSettings, kn as EditQueuedMessageRequest, kr as prettifyError, kt as ResolveInboxRequest, l as upgradeWebSocket, ln as parseGithubPrId, lr as _null, lt as AutomationFileFrontmatter, m as ImageGenerationError, mn as KillSwitchRequest, mr as int, mt as ListAutomationsQuery, n as readLock, nn as GithubIssue, nr as McpServerTarget, nt as BrowserViewportRequest, o as tryDecodeURIComponent, on as MergePrRequest, or as ReasoningEffort, ot as DuplicateAutomationRequest, p as resolveImageOutput, pn as FactoryTuning, pr as discriminatedUnion, pt as ListAutomationRunsQuery, q as passwordProblem, qn as InboxItem, qt as AppPointer, r as isAlive, rn as GithubLabelRequest, rr as McpServerUpsertRequest, rt as BrowserWsQuery, s as bufferToFormData, sn as TriageIssueRequest, sr as datetime, st as ExportAutomationsQuery, tn as GithubCommentRequest, tr as McpServerDiffRequest, tt as BrowserOpenRequest, u as ImageEngineRegistry, un as DiscoveryArea, ur as array, ut as AutomationGuardsPatch, v as installClaudeSdk, vn as isFactoryMode, vr as number, vt as TriageDecisionRequest, w as ownNodeEnv, wn as AutomationTrigger, wr as union$1, wt as FileReadQuery, x as resolveNpm, xn as AutomationAction, xr as preprocess, xt as UpdateAutomationProjectSettingsRequest, y as isClaudeSdkInstalled, yn as Artifact, yr as object, yt as TriageReport, z as UpdateSessionRequest, zn as ProjectConfigFile, zt as UpdateProjectRequest } from "./runner-Doy0yaNT.js";
 import { createRequire } from "node:module";
-import fs, { accessSync, closeSync, constants, copyFileSync, cpSync, createReadStream, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
-import { homedir, tmpdir } from "node:os";
+import fs, { accessSync, appendFileSync, closeSync, constants, copyFileSync, cpSync, createReadStream, existsSync, mkdirSync, openSync, readFileSync, readSync, readdirSync, realpathSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
+import { homedir, networkInterfaces, tmpdir } from "node:os";
 import { basename, delimiter, dirname, extname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
 import { isDeepStrictEqual, parseArgs } from "node:util";
-import crypto$1, { createHash, randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import crypto$1, { createHash, randomBytes, randomInt, randomUUID, scrypt, timingSafeEqual } from "node:crypto";
 import { execFile, spawn } from "node:child_process";
 import { gunzipSync } from "node:zlib";
+import { createInterface } from "node:readline";
 import { open, rename } from "node:fs/promises";
 import { Readable } from "node:stream";
 import { DatabaseSync } from "node:sqlite";
+import { createServer } from "node:net";
 import { createRequire as createRequire$1 } from "module";
 import { versions } from "node:process";
 // ../../packages/contracts/src/vision.ts
@@ -120,6 +122,368 @@ function parseProtectedAreas(lines) {
 		topics: [...topics]
 	};
 }
+// ../server/src/network/addresses.ts
+/** `::ffff:192.168.1.2` -> `192.168.1.2`; other addresses unchanged (lower case). */
+function normalizeAddress(address) {
+	const lower = (address ?? "").trim().toLowerCase();
+	return lower.startsWith("::ffff:") && lower.includes(".") ? lower.slice(7) : lower;
+}
+function ipv4Octets(address) {
+	const parts = address.split(".");
+	if (parts.length !== 4) return void 0;
+	const octets = parts.map((p) => /^\d{1,3}$/.test(p) ? Number(p) : NaN);
+	return octets.every((o) => o >= 0 && o <= 255) ? octets : void 0;
+}
+/**
+* Is this peer on this machine? `127.0.0.0/8`, `::1` and their IPv4-mapped forms are; an empty
+* or unknown address is not (fail closed: it counts as remote).
+*/
+function isLoopbackAddress(address) {
+	const normalized = normalizeAddress(address);
+	if (normalized === "::1" || normalized === "0:0:0:0:0:0:0:1") return true;
+	return ipv4Octets(normalized)?.[0] === 127;
+}
+/** Tailscale (and other CGNAT VPNs) hand out addresses in `100.64.0.0/10`. */
+function isVpnRange(address) {
+	const octets = ipv4Octets(address);
+	return octets !== void 0 && octets[0] === 100 && octets[1] >= 64 && octets[1] <= 127;
+}
+/** Link-local `169.254.0.0/16` (no DHCP lease): never useful to a phone. */
+function isLinkLocal(address) {
+	const octets = ipv4Octets(address);
+	return octets?.[0] === 169 && octets[1] === 254;
+}
+/** Names of VPN interfaces, recognised so their address is labelled as a VPN. */
+const VPN_NAME = /tailscale|wireguard|wg\d|utun|zerotier|\bzt|tun\d|vpn/i;
+/**
+* Host-only virtual adapters (Hyper-V/WSL, Docker, VirtualBox, VMware, libvirt): no phone can
+* reach them, so they are neither listed nor accepted in `Host`/`Origin`.
+*/
+const VIRTUAL_NAME = /^(vethernet|docker\d*|br-|veth|virbr|vmnet|vboxnet)|virtualbox|vmware|hyper-v/i;
+/**
+* Every address CodeDen answers on for `port`: this machine (`localhost`) first, then each
+* non-internal IPv4 address, LAN before VPN, leaving out host-only virtual adapters. Tailscale's range, and interfaces named like a VPN,
+* count as `vpn`. Interfaces are injectable for tests.
+*/
+function listAddresses(port, interfaces = networkInterfaces()) {
+	const local = {
+		kind: "local",
+		label: "This computer",
+		interfaceName: null,
+		host: "localhost",
+		url: `http://localhost:${port}`
+	};
+	const found = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const [name, infos] of Object.entries(interfaces)) for (const info of infos ?? []) {
+		if (info.family !== "IPv4" || info.internal) continue;
+		const host = info.address;
+		if (seen.has(host) || isLinkLocal(host) || isLoopbackAddress(host)) continue;
+		if (VIRTUAL_NAME.test(name) && !isVpnRange(host)) continue;
+		seen.add(host);
+		const vpn = isVpnRange(host) || VPN_NAME.test(name);
+		const tailscale = isVpnRange(host) || /tailscale/i.test(name);
+		found.push({
+			kind: vpn ? "vpn" : "lan",
+			label: tailscale ? "Tailscale" : vpn ? `VPN (${name})` : name,
+			interfaceName: name,
+			host,
+			url: `http://${host}:${port}`
+		});
+	}
+	found.sort((a, b) => Number(a.kind === "vpn") - Number(b.kind === "vpn"));
+	return [local, ...found];
+}
+// ../server/src/network/words.ts
+/**
+* Short, common, easy-to-type English words for generated network-access passphrases
+* (`generatePassphrase`). Lower case, 3 to 9 letters, no duplicates (a test keeps it so).
+*/
+const PASSPHRASE_WORDS = `
+able acid acorn actor adapt adult agent agree ahead aim air alarm album alert alien alley
+alpine amber amount anchor angle ankle answer apple april apron arch arena argue arm armor
+army arrow art ash aspen atlas atom attic audio aunt autumn avenue award awake axis bacon
+badge bag bake balcony ball bamboo banana band bank barn barrel basil basket bath beach
+beam bean bear beard beat bee beetle bell belt bench berry bike bird biscuit bishop bitter
+blade blank blast blaze blend blink block bloom blue board boat body bolt bone bonus book
+boost boot border bottle bounce bowl box brain branch brass brave bread breeze brick bridge
+brief bright brisk broom brush bubble bucket buddy budget buffalo bugle build bulb bundle
+bunny burger burst bus butter button cabin cable cactus cake calm camel camera camp canal
+candle candy canoe canvas canyon cape captain car carbon card cargo carpet carrot cart case
+castle cat cave cedar cello cereal chain chair chalk champ chapel charm chart chase cheese
+chef cherry chess chest chick chief child chili chimney chin chip choir chorus cider cinema
+circle city clam clap clay clerk cliff climb clock cloud clover clown club coach coal coast
+coat cobra cocoa coconut code coffee coin collar color comet comic compass cookie copper
+coral cord corn cottage cotton couch cousin cove cow crab craft crane crater crayon cream
+creek crew cricket crisp crop cross crowd crown crumb crystal cube cup curtain curve cushion
+cycle daisy dance dawn deck deer delta denim depth desert desk dial diary diesel dinner
+dish diver dock doctor dog dollar dolphin donkey donut door dove dragonfly drama drawer
+dream dress drift drill drum duck dune dusk dust eagle earth easel echo eclipse edge eel
+egg elbow elder elk ember empty engine entry envoy epic equal error essay estate ethic
+event exit fabric falcon fame family fancy farm feast feather fence fern ferry festival
+fiber field fig film finch finger fire fish flag flame flash fleet flint float flock flood
+floor flour flower flute focus fog foil folk forest forge fork fossil fox frame frost fruit
+fudge fuel gadget galaxy garden garlic gate gauge gecko gem genre ghost giant ginger giraffe
+glass glide globe glove glow glue goat gold golf goose gopher gospel grain granite grape
+graph grass gravel gravy green grid grill grove guitar gulf gym habit hammer hamster hand
+harbor harp harvest hat hawk hazel heart hedge helmet hen herb hero heron hill hinge hippo
+hobby hockey honey hood hook horizon horn horse hotel hound house hub humor hut iceberg
+icon idea igloo inch index ink input insect iron island ivory ivy jacket jaguar jam jar
+jazz jelly jet jewel jigsaw jockey judge juice jungle kayak kernel kettle key kidney king
+kite kitten kiwi knee knife knot koala label ladder lagoon lake lamb lamp lantern laptop
+lark laser latch lava lawn layer leaf ledge lemon lens leopard letter lever library lily
+lime linen lion lizard llama lobster locket lodge logic lotus lunar lunch lynx magnet
+mango manor maple marble market marsh mask meadow medal melon memory mentor menu metal
+meteor mint mirror mitten moat model mole mongoose moon moose mosaic moss moth motor
+mountain mouse muffin mule mural museum mushroom music mustard nail napkin native nebula
+needle nest net nickel noble noodle north notch novel nugget nurse nutmeg oak oasis ocean
+octopus olive omelet onion opal opera orange orbit orchard orchid organ otter outlet oval
+oven owl oyster paddle page paint palace palm panda panel panther paper parade parcel park
+parrot pasta patch path peach peanut pear pebble pecan pedal pelican pencil pepper piano
+pickle picnic pigeon pillow pilot pine pirate pizza planet plank plaza plum pocket poem
+polar pond pony poppy porch potato pottery powder prairie prism prize puddle pulse pumpkin
+puppet puppy puzzle python quail quartz queen quest quill quilt quiz rabbit raccoon radar
+radio raft rain raisin rake ranch raven razor recipe reef relay ribbon rice ridge rifle
+ring river road robin robot rocket rodeo roof rook rope rose rover ruby rudder rug ruler
+saddle safari saga sail salad salmon salt sand sandal satin saucer sauna scale scarf school
+scooter scout screen scroll seal season seed shark sheep shelf shell sherpa shield ship
+shirt shoe shore shovel shrimp signal silk silver singer siren sketch ski skunk sky sled
+slope sloth smile snail snake snow soap soccer sock sofa solar soup spark sparrow spear
+sphere spice spider spinach spoon spring sprout spruce squad squid stable stadium stamp
+star statue steam steel stem stereo stone stool storm stove straw stream street string
+studio sugar suit summit sun surf swamp swan sweater swing sword syrup table tablet taco
+tail talent tango tank tea teapot temple tennis tent thistle thorn thread thunder ticket
+tide tiger timber toast toffee tomato tonic topaz torch tornado tortoise towel tower toy
+track tractor trail train tram tree trick trolley trophy trout truck trumpet tulip tuna
+tunnel turkey turnip turtle tutor twig umbrella unicorn urban vacuum valley valve van vase
+velvet vessel violet violin visor voice volcano voyage waffle wagon walnut walrus wand
+wave wax weasel whale wheat wheel whistle willow window winter wizard wolf wombat wood
+wool yacht yak yard yarn yeti yogurt zebra zero zigzag zinc zipper zone
+`.trim().split(/\s+/);
+// ../server/src/network/password.ts
+/** scrypt cost: N=2^15, r=8, p=1 (about 32 MiB and tens of milliseconds per hash). */
+const DEFAULT_COST = {
+	N: 2 ** 15,
+	r: 8,
+	p: 1
+};
+const KEY_LENGTH = 32;
+const SALT_BYTES = 16;
+function scryptAsync(password, salt, opts) {
+	return new Promise((resolve, reject) => {
+		const maxmem = 256 * (opts.N ?? DEFAULT_COST.N) * (opts.r ?? DEFAULT_COST.r) + 1048576;
+		scrypt(password.normalize("NFKC"), salt, KEY_LENGTH, {
+			...opts,
+			maxmem
+		}, (error, key) => error ? reject(error) : resolve(key));
+	});
+}
+/**
+* Hash a network-access password with scrypt and a random salt:
+* `scrypt$<N>$<r>$<p>$<salt b64>$<hash b64>`. The password itself is never stored.
+*/
+async function hashPassword(password, cost = DEFAULT_COST) {
+	const salt = randomBytes(SALT_BYTES);
+	const key = await scryptAsync(password, salt, cost);
+	return [
+		"scrypt",
+		cost.N,
+		cost.r,
+		cost.p,
+		salt.toString("base64"),
+		key.toString("base64")
+	].join("$");
+}
+/** Check a password against a stored hash in constant time; false for malformed hashes. */
+async function verifyPassword(password, stored) {
+	const parts = stored.split("$");
+	if (parts.length !== 6 || parts[0] !== "scrypt") return false;
+	const [N, r, p] = parts.slice(1, 4).map(Number);
+	if (!N || !r || !p || N > 2 ** 20 || r > 32 || p > 16) return false;
+	const salt = Buffer.from(parts[4], "base64");
+	const expected = Buffer.from(parts[5], "base64");
+	if (expected.length !== KEY_LENGTH) return false;
+	try {
+		const key = await scryptAsync(password, salt, {
+			N,
+			r,
+			p
+		});
+		return timingSafeEqual(key, expected);
+	} catch {
+		return false;
+	}
+}
+/**
+* A random passphrase of five words from `PASSPHRASE_WORDS`, joined with dashes (about 49
+* bits; always longer than the 15-character minimum). Drawn again in the rare case the rules
+* refuse it.
+*/
+function generatePassphrase(pick = randomInt) {
+	for (;;) {
+		const phrase = Array.from({ length: 5 }, () => PASSPHRASE_WORDS[pick(PASSPHRASE_WORDS.length)]).join("-");
+		if (!passwordProblem(phrase)) return phrase;
+	}
+}
+// ../server/src/json-file.ts
+/** Read and parse a JSON file; `undefined` when missing or unparsable. */
+function readJsonFile(file) {
+	try {
+		return JSON.parse(readFileSync(file, "utf8"));
+	} catch {
+		return;
+	}
+}
+/** Write JSON atomically (temp file + rename) so readers never see a partial file. */
+function writeJsonFile(file, value, mode) {
+	mkdirSync(dirname(file), { recursive: true });
+	const tmp = `${file}.${process.pid}.tmp`;
+	writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, mode ? { mode } : void 0);
+	renameSync(tmp, file);
+}
+// ../server/src/network/store.ts
+/** Prefix of remote session tokens, so they are recognisable in a cookie jar. */
+const TOKEN_PREFIX = "cds_";
+const SESSION_MS = 7776e6;
+/** `lastSeenAt` is written to disk at most this often per session. */
+const SEEN_WRITE_MS = 6e4;
+const LABEL_MAX = 200;
+function sha256$3(token) {
+	return createHash("sha256").update(token).digest("hex");
+}
+/** A password the rules refuse, with the reason in plain words. */
+var PasswordRuleError = class extends Error {
+	code = "weak_password";
+};
+/**
+* `<home>/remote-access.json` (§15.1): the network switch, the password's scrypt hash and the
+* remote sessions (hashes of their tokens only). Shared by the server and the `codeden
+* password` / `codeden network` commands when no server is running.
+*/
+var RemoteAccessStore = class {
+	file;
+	now;
+	data;
+	seenWritten = /* @__PURE__ */ new Map();
+	constructor(file, now = Date.now) {
+		this.file = file;
+		this.now = now;
+		this.data = this.load();
+	}
+	get enabled() {
+		return this.data.enabled;
+	}
+	get passwordSet() {
+		return this.data.password !== null;
+	}
+	get passwordSetAt() {
+		return this.data.password?.setAt ?? null;
+	}
+	/** Re-read the file (the CLI may have changed it while the server was stopped). */
+	reload() {
+		this.data = this.load();
+	}
+	/**
+	* Set the password after checking the rules (throws `PasswordRuleError`), and sign out every
+	* remote device.
+	*/
+	async setPassword(password) {
+		const problem = passwordProblem(password);
+		if (problem) throw new PasswordRuleError(problem);
+		const hash = await hashPassword(password);
+		this.data = {
+			...this.data,
+			password: {
+				hash,
+				setAt: new Date(this.now()).toISOString()
+			},
+			sessions: []
+		};
+		this.save();
+	}
+	async checkPassword(password) {
+		const stored = this.data.password?.hash;
+		return stored ? verifyPassword(password, stored) : false;
+	}
+	/** Turn network access on or off. Turning it on without a password throws. */
+	setEnabled(enabled) {
+		if (enabled && !this.passwordSet) throw new Error("Set a network access password before turning network access on.");
+		this.data = {
+			...this.data,
+			enabled
+		};
+		this.save();
+	}
+	/** Start a 90-day session for a device; returns the token for its cookie (stored hashed). */
+	createSession(device) {
+		const token = `${TOKEN_PREFIX}${randomBytes(32).toString("base64url")}`;
+		const now = this.now();
+		const session = {
+			id: randomUUID(),
+			tokenHash: sha256$3(token),
+			label: device.label.slice(0, LABEL_MAX) || "Unknown device",
+			address: device.address,
+			createdAt: new Date(now).toISOString(),
+			lastSeenAt: new Date(now).toISOString(),
+			expiresAt: new Date(now + SESSION_MS).toISOString()
+		};
+		this.data = {
+			...this.data,
+			sessions: [...this.liveSessions(), session]
+		};
+		this.save();
+		return {
+			token,
+			session
+		};
+	}
+	/** The live session for a cookie token (and note that it was seen), else undefined. */
+	verifySession(token) {
+		if (!token?.startsWith(TOKEN_PREFIX)) return void 0;
+		const hash = sha256$3(token);
+		const now = this.now();
+		const session = this.data.sessions.find((s) => s.tokenHash === hash);
+		if (!session || Date.parse(session.expiresAt) <= now) return void 0;
+		session.lastSeenAt = new Date(now).toISOString();
+		if (now - (this.seenWritten.get(session.id) ?? 0) >= SEEN_WRITE_MS) {
+			this.seenWritten.set(session.id, now);
+			this.save();
+		}
+		return session;
+	}
+	/** Unexpired sessions, oldest first. */
+	liveSessions() {
+		const now = this.now();
+		return this.data.sessions.filter((s) => Date.parse(s.expiresAt) > now);
+	}
+	/** Sign out one device; false when there was no such session. */
+	revoke(id) {
+		const before = this.data.sessions.length;
+		this.data = {
+			...this.data,
+			sessions: this.data.sessions.filter((s) => s.id !== id)
+		};
+		if (this.data.sessions.length === before) return false;
+		this.save();
+		return true;
+	}
+	/** Sign out every device. */
+	revokeAll() {
+		this.data = {
+			...this.data,
+			sessions: []
+		};
+		this.save();
+	}
+	load() {
+		if (!existsSync(this.file)) return RemoteAccessFile.parse({});
+		const parsed = RemoteAccessFile.safeParse(readJsonFile(this.file) ?? {});
+		return parsed.success ? parsed.data : RemoteAccessFile.parse({});
+	}
+	save() {
+		writeJsonFile(this.file, this.data, 384);
+	}
+};
 // ../server/src/paths.ts
 /**
 * Resolve the data directory (§6): explicit value, then `CODEDEN_HOME`, then `~/.codeden`.
@@ -138,6 +502,10 @@ function homePaths(home) {
 		db: join(home, "codeden.db"),
 		settings: join(home, "settings.json"),
 		token: join(home, "install-token"),
+		/** Network access switch, password hash and remote sessions (§15.1). */
+		remoteAccess: join(home, "remote-access.json"),
+		/** Failed remote sign-ins (address and time, never the password). */
+		remoteAccessLog: join(home, "logs", "remote-access.log"),
 		serverLock: join(home, "server.json"),
 		runnerDir: join(home, "runner"),
 		runnerLock: join(home, "runner", "runner.json"),
@@ -8128,22 +8496,6 @@ function ingestRunnerEvent(db, store, runnerId, msg) {
 		ackSeq: msg.seq
 	};
 }
-// ../server/src/json-file.ts
-/** Read and parse a JSON file; `undefined` when missing or unparsable. */
-function readJsonFile(file) {
-	try {
-		return JSON.parse(readFileSync(file, "utf8"));
-	} catch {
-		return;
-	}
-}
-/** Write JSON atomically (temp file + rename) so readers never see a partial file. */
-function writeJsonFile(file, value, mode) {
-	mkdirSync(dirname(file), { recursive: true });
-	const tmp = `${file}.${process.pid}.tmp`;
-	writeFileSync(tmp, `${JSON.stringify(value, null, 2)}\n`, mode ? { mode } : void 0);
-	renameSync(tmp, file);
-}
 // ../server/src/runner/lock.ts
 /** True when a process with this pid exists (EPERM still means it exists). */
 function isProcessAlive(pid) {
@@ -20908,6 +21260,289 @@ function createMcpHandler(deps) {
 		}
 	};
 }
+// ../server/src/network/rate-limit.ts
+/** Failures allowed before each attempt has to wait. */
+const FREE_FAILURES = 3;
+/** First wait once the free failures are used up; it doubles with each failure. */
+const BASE_DELAY_MS = 1e3;
+const MAX_DELAY_MS = 3e4;
+/** This many failures inside the window lock the address out. */
+const LOCKOUT_FAILURES = 10;
+const WINDOW_MS = 9e5;
+const LOCKOUT_MS = 9e5;
+/**
+* Sign-in throttling per client address (§15.1). Only failed attempts count. After three
+* failures each attempt waits 1 s, 2 s, 4 s … up to 30 s after the last failure; ten failures
+* within 15 minutes lock the address out for 15 minutes. Other addresses are unaffected, and a
+* successful sign-in clears the address. Kept in memory: a restart forgets it.
+*/
+var SignInLimiter = class SignInLimiter {
+	now;
+	records = /* @__PURE__ */ new Map();
+	constructor(now = Date.now) {
+		this.now = now;
+	}
+	/** Wait required before the `failures`-th failure may be followed by another attempt. */
+	static delayAfter(failures) {
+		if (failures < FREE_FAILURES) return 0;
+		return Math.min(MAX_DELAY_MS, BASE_DELAY_MS * 2 ** (failures - FREE_FAILURES));
+	}
+	/** May `address` try a password now? */
+	check(address) {
+		const record = this.prune(address);
+		if (!record) return { allowed: true };
+		const now = this.now();
+		if (record.lockedUntil > now) return {
+			allowed: false,
+			reason: "locked_out",
+			retryAfterMs: record.lockedUntil - now
+		};
+		const last = record.failures.at(-1);
+		const wait = last === void 0 ? 0 : last + SignInLimiter.delayAfter(record.failures.length) - now;
+		return wait > 0 ? {
+			allowed: false,
+			reason: "rate_limited",
+			retryAfterMs: wait
+		} : { allowed: true };
+	}
+	/** Record a wrong password from `address`. */
+	fail(address) {
+		const now = this.now();
+		const record = this.prune(address) ?? {
+			failures: [],
+			lockedUntil: 0
+		};
+		record.failures.push(now);
+		if (record.failures.length >= LOCKOUT_FAILURES) {
+			record.lockedUntil = now + LOCKOUT_MS;
+			record.failures = [];
+		}
+		this.records.set(address, record);
+	}
+	/** A correct password: forget the address's failures. */
+	succeed(address) {
+		this.records.delete(address);
+	}
+	/** Drop failures older than the window; returns the record if anything is left. */
+	prune(address) {
+		const record = this.records.get(address);
+		if (!record) return void 0;
+		const now = this.now();
+		record.failures = record.failures.filter((t) => now - t < WINDOW_MS);
+		if (record.failures.length === 0 && record.lockedUntil <= now) {
+			this.records.delete(address);
+			return;
+		}
+		return record;
+	}
+};
+// ../server/src/network/access.ts
+/** Interface addresses are re-read at most this often (Host/Origin checks run per request). */
+const ADDRESS_CACHE_MS = 5e3;
+/**
+* Network access (§15.1): owns the switch, the password, remote sessions, the sign-in limiter
+* and where the HTTP listener is bound. Turning access on moves the listener to `0.0.0.0`
+* (same port); off moves it back to `127.0.0.1` and drops remote connections. The runner is
+* never involved.
+*/
+var NetworkAccess = class {
+	opts;
+	store;
+	limiter;
+	listener;
+	interfaces;
+	log;
+	cached;
+	constructor(opts) {
+		this.opts = opts;
+		this.store = opts.store;
+		this.listener = opts.listener;
+		this.interfaces = opts.interfaces ?? (() => void 0);
+		this.limiter = new SignInLimiter(opts.now);
+		this.log = opts.log ?? (() => {});
+	}
+	/** On only when switched on *and* a password is set: never bind beyond loopback without one. */
+	get enabled() {
+		return this.store.enabled && this.store.passwordSet;
+	}
+	/** Where the listener should be bound for the stored settings. */
+	desiredHost() {
+		return this.enabled ? "0.0.0.0" : "127.0.0.1";
+	}
+	get port() {
+		return this.listener.port;
+	}
+	/** Every address the server would answer on (localhost first), cached briefly. */
+	candidates() {
+		const now = Date.now();
+		const port = this.listener.port;
+		if (!this.cached || this.cached.port !== port || now - this.cached.at > ADDRESS_CACHE_MS) this.cached = {
+			at: now,
+			port,
+			addresses: listAddresses(port, this.interfaces())
+		};
+		return this.cached.addresses;
+	}
+	/** Addresses it answers on now: localhost only while off. */
+	addresses() {
+		const all = this.candidates();
+		return this.listener.host === "0.0.0.0" ? all : all.filter((a) => a.kind === "local");
+	}
+	/** The machine's own LAN/VPN hosts accepted in `Host` and `Origin` while access is on. */
+	ownHosts() {
+		if (!this.enabled || this.listener.host !== "0.0.0.0") return /* @__PURE__ */ new Set();
+		return new Set(this.candidates().filter((a) => a.kind !== "local").map((a) => a.host));
+	}
+	status(caller) {
+		return {
+			enabled: this.enabled,
+			passwordSet: this.store.passwordSet,
+			passwordSetAt: this.store.passwordSetAt,
+			listening: this.listener.host === "0.0.0.0" ? "network" : "loopback",
+			port: this.listener.port,
+			addresses: this.addresses(),
+			candidates: this.candidates(),
+			devices: this.store.liveSessions().map((s) => ({
+				id: s.id,
+				label: s.label,
+				address: s.address,
+				createdAt: s.createdAt,
+				lastSeenAt: s.lastSeenAt,
+				expiresAt: s.expiresAt,
+				current: s.id === caller.sessionId
+			})),
+			remote: caller.remote
+		};
+	}
+	/** Turn network access on (needs a password) or off, and move the listener to match. */
+	async setEnabled(enabled) {
+		this.store.setEnabled(enabled);
+		await this.applyBinding();
+	}
+	/** Bind the listener where the stored settings say; drops remote connections when off. */
+	async applyBinding() {
+		const host = this.desiredHost();
+		await this.listener.rebind(host);
+		this.cached = void 0;
+		if (host === "127.0.0.1") this.listener.dropRemote();
+		this.log(host === "0.0.0.0" ? `network access on: ${this.addresses().map((a) => a.url).join(", ")}` : "network access off: listening on 127.0.0.1 only");
+	}
+	/** Set (or generate) the password; signs out every remote device. Returns a generated one. */
+	async setPassword(input) {
+		const generated = "generate" in input ? generatePassphrase() : null;
+		await this.store.setPassword(generated ?? input.password);
+		this.listener.dropRemote();
+		this.log("network access password changed: every remote device was signed out");
+		return generated;
+	}
+	/** Sign out one device (and close remote connections so it notices). */
+	revoke(id) {
+		const revoked = this.store.revoke(id);
+		if (revoked) this.listener.dropRemote();
+		return revoked;
+	}
+	revokeAll() {
+		this.store.revokeAll();
+		this.listener.dropRemote();
+	}
+	/** Note a failed sign-in with its address (the password is never logged). */
+	recordFailedSignIn(address, reason) {
+		const line = `${(/* @__PURE__ */ new Date()).toISOString()} failed sign-in from ${address || "unknown"}: ${reason}`;
+		this.log(`network: ${line}`);
+		if (this.opts.securityLogFile) try {
+			appendFileSync(this.opts.securityLogFile, `${line}\n`, { mode: 384 });
+		} catch {}
+	}
+};
+// ../server/src/network/listener.ts
+/** How long a rebind keeps retrying while the OS releases the port. */
+const REBIND_TIMEOUT_MS = 5e3;
+/**
+* The TCP listener in front of the HTTP server (§15.1). The HTTP server (with its WebSocket
+* upgrade handling) never listens itself: this accepts connections and hands them over, so
+* switching between `127.0.0.1` and `0.0.0.0` swaps only the listening socket. Open
+* connections, including the UI's WebSockets, carry on, and the runner is untouched.
+*/
+var HttpListener = class {
+	http;
+	server;
+	sockets = /* @__PURE__ */ new Set();
+	boundHost = "127.0.0.1";
+	boundPort = 0;
+	constructor(http) {
+		this.http = http;
+	}
+	get host() {
+		return this.boundHost;
+	}
+	get port() {
+		return this.boundPort;
+	}
+	/** Bind for the first time (`port` 0 picks a free port); resolves with the port. */
+	async listen(port, host) {
+		this.server = await this.bind(port, host);
+		this.boundHost = host;
+		const address = this.server.address();
+		this.boundPort = typeof address === "object" && address ? address.port : port;
+		return this.boundPort;
+	}
+	/** Move the listener to `host` on the same port. Open connections stay open. */
+	async rebind(host) {
+		if (host === this.boundHost && this.server) return;
+		this.server?.close();
+		this.server = void 0;
+		const deadline = Date.now() + REBIND_TIMEOUT_MS;
+		for (;;) try {
+			this.server = await this.bind(this.boundPort, host);
+			this.boundHost = host;
+			return;
+		} catch (error) {
+			if (error.code !== "EADDRINUSE" || Date.now() > deadline) {
+				if (host !== "127.0.0.1") {
+					this.server = await this.bind(this.boundPort, "127.0.0.1");
+					this.boundHost = "127.0.0.1";
+				}
+				throw error;
+			}
+			await new Promise((r) => setTimeout(r, 50));
+		}
+	}
+	/** Close every connection that did not come from this machine (sign-outs, network off). */
+	dropRemote() {
+		let dropped = 0;
+		for (const socket of this.sockets) if (!isLoopbackAddress(socket.remoteAddress)) {
+			socket.destroy();
+			dropped++;
+		}
+		return dropped;
+	}
+	/** Stop listening and close every connection. */
+	async close() {
+		const server = this.server;
+		this.server = void 0;
+		for (const socket of this.sockets) socket.destroy();
+		this.sockets.clear();
+		if (server) await new Promise((resolve) => server.close(() => resolve()));
+	}
+	bind(port, host) {
+		return new Promise((resolve, reject) => {
+			const server = createServer((socket) => {
+				this.sockets.add(socket);
+				socket.once("close", () => this.sockets.delete(socket));
+				this.http.emit("connection", socket);
+			});
+			server.once("error", reject);
+			server.listen({
+				port,
+				host,
+				exclusive: true
+			}, () => {
+				server.off("error", reject);
+				resolve(server);
+			});
+		});
+	}
+};
 // ../server/src/services/errors.ts
 /**
 * An expected failure with a machine-readable code. Routes turn it into
@@ -20928,7 +21563,7 @@ const notFound = (message, code = "not_found") => new ServiceError(404, code, me
 const conflict = (message, code = "conflict") => new ServiceError(409, code, message);
 const forbidden = (message, code = "forbidden") => new ServiceError(403, code, message);
 /** Human-readable message of any thrown value. */
-function errorMessage(error) {
+function errorMessage$1(error) {
 	return error instanceof Error ? error.message : String(error);
 }
 // ../server/src/services/runner-port.ts
@@ -21237,7 +21872,7 @@ var BrowserBridge = class {
 		send$1(v.ws, {
 			type: "error",
 			code,
-			message: errorMessage(error)
+			message: errorMessage$1(error)
 		});
 	}
 	add(v) {
@@ -21753,7 +22388,7 @@ var TerminalBridge = class {
 				}
 				this.handle(ptyId, msg).catch((error) => control(ws, {
 					type: "error",
-					message: errorMessage(error)
+					message: errorMessage$1(error)
 				}));
 			},
 			onClose: (_event, ws) => {
@@ -21827,7 +22462,7 @@ var TerminalBridge = class {
 		} catch (error) {
 			control(ws, {
 				type: "error",
-				message: errorMessage(error)
+				message: errorMessage$1(error)
 			});
 			ws.close(1011, "terminal unavailable");
 		}
@@ -21985,6 +22620,14 @@ const setCookie = (c, name, value, opt) => {
 	const cookie = generateCookie(name, value, opt);
 	c.header("Set-Cookie", cookie, { append: true });
 };
+const deleteCookie = (c, name, opt) => {
+	const deletedCookie = getCookie(c, name, opt?.prefix);
+	setCookie(c, name, "", {
+		...opt,
+		maxAge: 0
+	});
+	return deletedCookie;
+};
 // ../../node_modules/.pnpm/hono@4.13.17/node_modules/hono/dist/validator/validator.js
 const jsonRegex = /^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/i;
 const multipartRegex = /^multipart\/form-data(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/i;
@@ -30955,7 +31598,7 @@ function unzipMarkdown(zipBase64) {
 		files = unzipSync(new Uint8Array(data), { filter: wanted });
 	} catch (error) {
 		if (error instanceof ServiceError) throw error;
-		throw badRequest(`Not a readable zip: ${errorMessage(error)}`, "invalid_zip");
+		throw badRequest(`Not a readable zip: ${errorMessage$1(error)}`, "invalid_zip");
 	}
 	return Object.entries(files).map(([name, bytes]) => {
 		if (bytes.length > AUTOMATION_IMPORT_LIMITS.maxFileChars) throw tooLarge(`${baseName(name)} is too large`);
@@ -31031,7 +31674,7 @@ function previewFile(file) {
 			fullPermissions: autonomy === "full"
 		};
 	} catch (error) {
-		return fail(errorMessage(error));
+		return fail(errorMessage$1(error));
 	}
 }
 /** Preview every file of an import. */
@@ -31304,6 +31947,271 @@ function imageRoutes(s) {
 function inboxRoutes(s) {
 	return new Hono().get("/", queryOf(ListInboxQuery), (c) => c.json(s.inbox.list(c.req.valid("query")))).get("/counts", (c) => c.json(s.inbox.counts())).get("/:id", (c) => c.json(s.inbox.get(c.req.param("id")))).post("/:id/resolve", jsonBody(ResolveInboxRequest), async (c) => c.json(await s.inbox.resolve(c.req.param("id"), c.req.valid("json"))));
 }
+// ../server/src/token.ts
+/** Generate a random URL-safe token (hex). */
+function generateToken(bytes = 32) {
+	return randomBytes(bytes).toString("hex");
+}
+/**
+* Load the per-install token from `file`, creating it on first run (§15). The file is
+* readable only by the user where the OS supports POSIX modes.
+*/
+function ensureInstallToken(file) {
+	if (existsSync(file)) {
+		const existing = readFileSync(file, "utf8").trim();
+		if (existing.length >= 32) return existing;
+	}
+	const token = generateToken();
+	writeFileSync(file, `${token}\n`, { mode: 384 });
+	return token;
+}
+/** Constant-time string comparison. */
+function tokensEqual(a, b) {
+	if (!a) return false;
+	const left = Buffer.from(a);
+	const right = Buffer.from(b);
+	return left.length === right.length && timingSafeEqual(left, right);
+}
+// ../server/src/security.ts
+const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
+	"127.0.0.1",
+	"localhost",
+	"[::1]",
+	"::1"
+]);
+/** Files a browser fetches without cookies to install the app (manifest, icons). */
+const PWA_FILES = /* @__PURE__ */ new Set([
+	"/manifest.webmanifest",
+	"/favicon.svg",
+	"/apple-touch-icon.png",
+	"/icons/icon-192.png",
+	"/icons/icon-512.png",
+	"/icons/maskable-192.png",
+	"/icons/maskable-512.png"
+]);
+/** Sign-in endpoints a signed-out remote device may call. */
+const AUTH_PATHS = /* @__PURE__ */ new Set([
+	"/api/auth/status",
+	"/api/auth/sign-in",
+	"/api/auth/sign-out"
+]);
+/** Hostname part of a Host header (`127.0.0.1:4317` -> `127.0.0.1`, `[::1]:80` -> `[::1]`). */
+function hostnameOf(host) {
+	if (host.startsWith("[")) return host.slice(0, host.indexOf("]") + 1);
+	const colon = host.lastIndexOf(":");
+	return colon === -1 ? host : host.slice(0, colon);
+}
+/** Origins for a server listening on `port`. */
+function loopbackOrigins(port) {
+	return [
+		`http://127.0.0.1:${port}`,
+		`http://localhost:${port}`,
+		`http://[::1]:${port}`
+	];
+}
+/**
+* The connection's peer address, from the socket itself. Headers such as `X-Forwarded-For`
+* are never consulted, so they can't make a request look local. Unknown counts as remote.
+*/
+function peerAddress(c) {
+	const env = c.env;
+	return normalizeAddress(env?.incoming?.socket?.remoteAddress);
+}
+/** Did this request come from another device? */
+function isRemoteRequest(c) {
+	return !isLoopbackAddress(peerAddress(c));
+}
+/** `Host` values for the machine's own addresses on `port`. */
+function ownHostValues(remote) {
+	const port = remote.port();
+	const values = /* @__PURE__ */ new Set();
+	for (const host of remote.ownHosts()) {
+		values.add(`${host}:${port}`);
+		if (port === 80) values.add(host);
+	}
+	return values;
+}
+/** Static UI files (served to signed-out remote devices so they can show the sign-in page). */
+function isShellRequest(c) {
+	const path = c.req.path;
+	return (c.req.method === "GET" || c.req.method === "HEAD") && !path.startsWith("/api/") && path !== "/ws" && !path.startsWith("/ws/") && path !== "/mcp";
+}
+/**
+* Request checks (§15, §15.1):
+* 1. `Host` must be a loopback name, or, with network access on, one of this machine's own
+*    LAN/VPN addresses on the server port (blocks DNS rebinding).
+* 2. `Origin`, when present, must be one of ours (blocks other websites, including other
+*    ports on the same host, which count as same-site for cookies, and `null`).
+* 3. Loopback peers need the install token via `Authorization: Bearer`, the HttpOnly cookie,
+*    or `?token=` (exchanged for the cookie and stripped from the URL with a redirect).
+* 4. Remote peers need a remote session cookie (from the password sign-in); the install token
+*    is never accepted from them, and loopback-only paths answer 404.
+*/
+function securityMiddleware(opts) {
+	return async (c, next) => {
+		const remote = isRemoteRequest(c);
+		const networkOn = opts.remote?.enabled() ?? false;
+		if (remote && !networkOn) return c.text("Network access is off", 403);
+		const host = c.req.header("host");
+		const hostName = host ? hostnameOf(host).toLowerCase() : "";
+		if (!(Boolean(host) && (LOOPBACK_HOSTS.has(hostName) || networkOn && opts.remote !== void 0 && ownHostValues(opts.remote).has(host)))) return c.text("Forbidden host", 403);
+		const origin = c.req.header("origin");
+		if (origin && !opts.allowedOrigins().has(origin)) return c.text("Forbidden origin", 403);
+		if (remote) return remoteGate(c, next, opts);
+		if (opts.publicPaths?.has(c.req.path) || PWA_FILES.has(c.req.path)) return next();
+		if (AUTH_PATHS.has(c.req.path)) return next();
+		const queryToken = c.req.query("token");
+		if (queryToken !== void 0) {
+			if (!tokensEqual(queryToken, opts.token)) return c.text("Invalid token", 401);
+			setCookie(c, opts.cookieName(), opts.token, {
+				httpOnly: true,
+				sameSite: "Strict",
+				path: "/"
+			});
+			if (c.req.method === "GET" && !c.req.path.startsWith("/api/") && c.req.path !== "/ws") {
+				const url = new URL(c.req.url);
+				url.searchParams.delete("token");
+				return c.redirect(`${url.pathname}${url.search}${url.hash}`, 302);
+			}
+			return next();
+		}
+		const auth = c.req.header("authorization");
+		if (tokensEqual(auth?.toLowerCase().startsWith("bearer ") ? auth.slice(7).trim() : void 0, opts.token) || tokensEqual(getCookie(c, opts.cookieName()), opts.token)) return next();
+		if (c.req.header("accept")?.includes("text/html")) return c.html(UNAUTHORIZED_PAGE, 401);
+		return c.json({ error: {
+			code: "unauthorized",
+			message: "Missing or invalid token"
+		} }, 401);
+	};
+}
+/** Remote peers: loopback-only paths are hidden, everything else needs a session. */
+async function remoteGate(c, next, opts) {
+	const path = c.req.path;
+	if (opts.loopbackOnlyPaths?.has(path)) return c.text("Not found", 404);
+	if (path === "/api/health" || AUTH_PATHS.has(path) || PWA_FILES.has(path)) {
+		await next();
+		return;
+	}
+	if (opts.remote?.verifySession(getCookie(c, opts.remote.sessionCookieName()))) {
+		await next();
+		return;
+	}
+	if (isShellRequest(c)) {
+		await next();
+		return;
+	}
+	return c.json({ error: {
+		code: "sign_in_required",
+		message: "Sign in to CodeDen"
+	} }, 401);
+}
+const UNAUTHORIZED_PAGE = `<!doctype html><html><head><meta charset="utf-8"><title>CodeDen</title>
+<style>body{font-family:system-ui,sans-serif;background:#0b0d10;color:#e6e8eb;display:grid;place-items:center;height:100vh;margin:0}
+main{max-width:28rem;text-align:center}code{background:#1b1f24;padding:.15rem .4rem;border-radius:.3rem}</style></head>
+<body><main><h1>CodeDen is locked</h1><p>Open CodeDen with <code>npx codeden</code> to get an authenticated link.</p></main></body></html>`;
+// ../server/src/routes/network.ts
+/** Session id of a remote caller, from its cookie. */
+function remoteSessionId(c, ctx) {
+	return ctx.network.store.verifySession(getCookie(c, ctx.sessionCookie()))?.id ?? null;
+}
+/** Changing network access is for this machine only (and the CLI). */
+function requireLocal(c) {
+	if (isRemoteRequest(c)) throw forbidden("Network access can only be changed on the computer running CodeDen.");
+}
+/**
+* `/api/network` (§15.1): status for everyone signed in; turning access on or off and the
+* password are loopback-only. Signed-in devices can be signed out from anywhere.
+*/
+function networkRoutes(ctx) {
+	const { network } = ctx;
+	const statusFor = (c) => network.status({
+		remote: isRemoteRequest(c),
+		sessionId: remoteSessionId(c, ctx)
+	});
+	return new Hono().get("/", (c) => c.json(statusFor(c))).put("/", jsonBody(SetNetworkAccessRequest), async (c) => {
+		requireLocal(c);
+		const { enabled } = c.req.valid("json");
+		if (enabled && !network.store.passwordSet) throw badRequest("Set a password before turning network access on.", "password_required");
+		await network.setEnabled(enabled);
+		return c.json(statusFor(c));
+	}).post("/password", jsonBody(SetNetworkPasswordRequest), async (c) => {
+		requireLocal(c);
+		let generated;
+		try {
+			generated = await network.setPassword(c.req.valid("json"));
+		} catch (error) {
+			if (error instanceof PasswordRuleError) throw badRequest(error.message, error.code);
+			throw error;
+		}
+		const body = {
+			status: statusFor(c),
+			generated
+		};
+		return c.json(body);
+	}).delete("/devices/:id", (c) => {
+		if (!network.revoke(c.req.param("id"))) throw notFound("No such device");
+		return c.json(statusFor(c));
+	}).delete("/devices", (c) => {
+		network.revokeAll();
+		return c.json(statusFor(c));
+	});
+}
+/** `/api/auth` (§15.1): sign-in for remote devices. Public; Host/Origin checks still apply. */
+function authRoutes(ctx) {
+	const { network } = ctx;
+	return new Hono().get("/status", (c) => {
+		const remote = isRemoteRequest(c);
+		const body = {
+			remote,
+			signedIn: remote ? remoteSessionId(c, ctx) !== null : tokensEqual(getCookie(c, ctx.tokenCookie()), ctx.token),
+			networkEnabled: network.enabled
+		};
+		return c.json(body);
+	}).post("/sign-in", jsonBody(SignInRequest), async (c) => {
+		const address = peerAddress(c);
+		const refuse = (status, code, message, retryAfterMs = null) => {
+			const retryAfterSec = retryAfterMs === null ? null : Math.ceil(retryAfterMs / 1e3);
+			if (retryAfterSec !== null) c.header("Retry-After", String(retryAfterSec));
+			const body = { error: {
+				code,
+				message,
+				retryAfterSec
+			} };
+			return c.json(body, status);
+		};
+		if (!network.enabled) return refuse(403, "network_off", "Network access is off.");
+		if (!isRemoteRequest(c)) return refuse(403, "network_off", "Sign-in is for other devices; this computer uses its own link.");
+		const gate = network.limiter.check(address);
+		if (!gate.allowed) {
+			const seconds = Math.ceil(gate.retryAfterMs / 1e3);
+			return gate.reason === "locked_out" ? refuse(429, "locked_out", `Too many wrong passwords. Try again in ${Math.ceil(seconds / 60)} min.`, gate.retryAfterMs) : refuse(429, "rate_limited", `Wait ${seconds} s before trying again.`, gate.retryAfterMs);
+		}
+		const { password } = c.req.valid("json");
+		if (!await network.store.checkPassword(password)) {
+			network.limiter.fail(address);
+			network.recordFailedSignIn(address, "wrong password");
+			return refuse(401, "invalid_password", "That password is not right.");
+		}
+		network.limiter.succeed(address);
+		const { token, session } = network.store.createSession({
+			label: c.req.header("user-agent") ?? "",
+			address: address || null
+		});
+		setCookie(c, ctx.sessionCookie(), token, {
+			httpOnly: true,
+			sameSite: "Lax",
+			secure: new URL(c.req.url).protocol === "https:",
+			path: "/",
+			maxAge: Math.floor((Date.parse(session.expiresAt) - Date.now()) / 1e3)
+		});
+		return c.json({ ok: true });
+	}).post("/sign-out", (c) => {
+		const id = remoteSessionId(c, ctx);
+		if (id) network.store.revoke(id);
+		deleteCookie(c, ctx.sessionCookie(), { path: "/" });
+		return c.json({ ok: true });
+	});
+}
 // ../server/src/routes/orchestration.ts
 /**
 * `/api/orchestration`: the orchestrator and PM chats (§8.1), notices, digests.
@@ -32258,7 +33166,7 @@ function createApi(ctx) {
 			uptimeSec: (Date.now() - ctx.startedAt) / 1e3
 		};
 		return c.json(body);
-	}).get("/snapshot", (c) => c.json(buildSnapshot(ctx))).get("/activity", (c) => c.json(buildActivity(s))).get("/sessions/:id/snapshot", (c) => c.json(buildSessionSnapshot(s, c.req.param("id")))).route("/projects", projectRoutes(s)).route("/projects", projectGithubRoutes(s)).route("/projects", projectFactoryRoutes(s)).route("/factory", factoryRoutes(s)).route("/prs", prRoutes(s)).route("/github", githubRoutes(s)).route("/sessions", sessionGithubRoutes(s)).route("/sessions", sessionRoutes(s)).route("/sessions", workbenchRoutes(s)).route("/sessions", sessionBrowserRoutes(s)).route("/browser", browserRoutes(s)).route("/images", imageRoutes(s)).route("/agent-config", agentConfigRoutes(s)).route("/voice", voiceRoutes(s)).route("/", speechRoutes(s)).route("/sessions", sessionAgentConfigRoutes(s)).route("/sessions", sessionFileRoutes(s)).route("/utility", utilityRoutes(s)).route("/inbox", inboxRoutes(s)).route("/orchestration", orchestrationRoutes(s)).route("/conflicts", conflictRoutes(s)).route("/automations", automationRoutes(s)).route("/projects", projectAutomationRoutes(s)).route("/usage", usageRoutes(s)).route("/setup", setupRoutes(s)).route("/updates", updateRoutes(s)).route("/artifacts", artifactRoutes(s)).route("/secrets", secretRoutes(s)).route("/", fileRoutes(s)).get("/settings", (c) => c.json(s.settings.get())).patch("/settings", async (c) => {
+	}).get("/snapshot", (c) => c.json(buildSnapshot(ctx))).get("/activity", (c) => c.json(buildActivity(s))).get("/sessions/:id/snapshot", (c) => c.json(buildSessionSnapshot(s, c.req.param("id")))).route("/projects", projectRoutes(s)).route("/projects", projectGithubRoutes(s)).route("/projects", projectFactoryRoutes(s)).route("/factory", factoryRoutes(s)).route("/prs", prRoutes(s)).route("/github", githubRoutes(s)).route("/sessions", sessionGithubRoutes(s)).route("/sessions", sessionRoutes(s)).route("/sessions", workbenchRoutes(s)).route("/sessions", sessionBrowserRoutes(s)).route("/browser", browserRoutes(s)).route("/images", imageRoutes(s)).route("/agent-config", agentConfigRoutes(s)).route("/voice", voiceRoutes(s)).route("/", speechRoutes(s)).route("/sessions", sessionAgentConfigRoutes(s)).route("/sessions", sessionFileRoutes(s)).route("/utility", utilityRoutes(s)).route("/inbox", inboxRoutes(s)).route("/orchestration", orchestrationRoutes(s)).route("/conflicts", conflictRoutes(s)).route("/automations", automationRoutes(s)).route("/projects", projectAutomationRoutes(s)).route("/usage", usageRoutes(s)).route("/setup", setupRoutes(s)).route("/updates", updateRoutes(s)).route("/artifacts", artifactRoutes(s)).route("/secrets", secretRoutes(s)).route("/network", networkRoutes(ctx.network)).route("/auth", authRoutes(ctx.network)).route("/", fileRoutes(s)).get("/settings", (c) => c.json(s.settings.get())).patch("/settings", async (c) => {
 		const patch = await c.req.json().catch(() => void 0);
 		if (!patch || typeof patch !== "object" || Array.isArray(patch)) throw badRequest("Expected a JSON object");
 		let settings;
@@ -32637,95 +33545,6 @@ function indexReader(file) {
 		}
 	};
 }
-// ../server/src/token.ts
-/** Generate a random URL-safe token (hex). */
-function generateToken(bytes = 32) {
-	return randomBytes(bytes).toString("hex");
-}
-/**
-* Load the per-install token from `file`, creating it on first run (§15). The file is
-* readable only by the user where the OS supports POSIX modes.
-*/
-function ensureInstallToken(file) {
-	if (existsSync(file)) {
-		const existing = readFileSync(file, "utf8").trim();
-		if (existing.length >= 32) return existing;
-	}
-	const token = generateToken();
-	writeFileSync(file, `${token}\n`, { mode: 384 });
-	return token;
-}
-/** Constant-time string comparison. */
-function tokensEqual(a, b) {
-	if (!a) return false;
-	const left = Buffer.from(a);
-	const right = Buffer.from(b);
-	return left.length === right.length && timingSafeEqual(left, right);
-}
-// ../server/src/security.ts
-const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
-	"127.0.0.1",
-	"localhost",
-	"[::1]",
-	"::1"
-]);
-/** Hostname part of a Host header (`127.0.0.1:4317` -> `127.0.0.1`, `[::1]:80` -> `[::1]`). */
-function hostnameOf(host) {
-	if (host.startsWith("[")) return host.slice(0, host.indexOf("]") + 1);
-	const colon = host.lastIndexOf(":");
-	return colon === -1 ? host : host.slice(0, colon);
-}
-/** Origins for a server listening on `port`. */
-function loopbackOrigins(port) {
-	return [
-		`http://127.0.0.1:${port}`,
-		`http://localhost:${port}`,
-		`http://[::1]:${port}`
-	];
-}
-/**
-* Request checks (§15):
-* 1. `Host` must be a loopback name (blocks DNS rebinding).
-* 2. `Origin`, when present, must be one of ours (blocks other websites, including other
-*    localhost ports, which count as same-site for cookies).
-* 3. A valid token via `Authorization: Bearer`, the HttpOnly cookie, or `?token=` (which is
-*    exchanged for the cookie and stripped from the URL with a redirect).
-*/
-function securityMiddleware(opts) {
-	return async (c, next) => {
-		const host = c.req.header("host");
-		if (!host || !LOOPBACK_HOSTS.has(hostnameOf(host).toLowerCase())) return c.text("Forbidden host", 403);
-		const origin = c.req.header("origin");
-		if (origin && !opts.allowedOrigins().has(origin)) return c.text("Forbidden origin", 403);
-		if (opts.publicPaths?.has(c.req.path)) return next();
-		const queryToken = c.req.query("token");
-		if (queryToken !== void 0) {
-			if (!tokensEqual(queryToken, opts.token)) return c.text("Invalid token", 401);
-			setCookie(c, opts.cookieName(), opts.token, {
-				httpOnly: true,
-				sameSite: "Strict",
-				path: "/"
-			});
-			if (c.req.method === "GET" && !c.req.path.startsWith("/api/") && c.req.path !== "/ws") {
-				const url = new URL(c.req.url);
-				url.searchParams.delete("token");
-				return c.redirect(`${url.pathname}${url.search}${url.hash}`, 302);
-			}
-			return next();
-		}
-		const auth = c.req.header("authorization");
-		if (tokensEqual(auth?.toLowerCase().startsWith("bearer ") ? auth.slice(7).trim() : void 0, opts.token) || tokensEqual(getCookie(c, opts.cookieName()), opts.token)) return next();
-		if (c.req.header("accept")?.includes("text/html")) return c.html(UNAUTHORIZED_PAGE, 401);
-		return c.json({ error: {
-			code: "unauthorized",
-			message: "Missing or invalid token"
-		} }, 401);
-	};
-}
-const UNAUTHORIZED_PAGE = `<!doctype html><html><head><meta charset="utf-8"><title>CodeDen</title>
-<style>body{font-family:system-ui,sans-serif;background:#0b0d10;color:#e6e8eb;display:grid;place-items:center;height:100vh;margin:0}
-main{max-width:28rem;text-align:center}code{background:#1b1f24;padding:.15rem .4rem;border-radius:.3rem}</style></head>
-<body><main><h1>CodeDen is locked</h1><p>Open CodeDen with <code>npx codeden</code> to get an authenticated link.</p></main></body></html>`;
 // ../server/src/mcp/define.ts
 /** Identity helper that infers a tool's input and scope types. */
 function defineTool(tool) {
@@ -32816,7 +33635,7 @@ var ToolRegistry = class {
 			};
 			this.log?.(`tool ${name} failed: ${error instanceof Error ? error.stack ?? error.message : String(error)}`);
 			return {
-				text: `${name} failed: ${errorMessage(error)}`,
+				text: `${name} failed: ${errorMessage$1(error)}`,
 				isError: true
 			};
 		}
@@ -43322,7 +44141,7 @@ var AutomationSources = class {
 				});
 				this.watchers.set(dir, watcher);
 			} catch (error) {
-				this.deps.log?.(`automations: cannot watch ${dir}: ${errorMessage(error)}`);
+				this.deps.log?.(`automations: cannot watch ${dir}: ${errorMessage$1(error)}`);
 			}
 		}
 	}
@@ -43333,7 +44152,7 @@ var AutomationSources = class {
 			try {
 				this.reload();
 			} catch (error) {
-				this.deps.log?.(`automations: reload failed: ${errorMessage(error)}`);
+				this.deps.log?.(`automations: reload failed: ${errorMessage$1(error)}`);
 			}
 		}, 200);
 		this.timer.unref();
@@ -44035,14 +44854,14 @@ var AutomationExecutor = class {
 				}
 			}
 		} catch (error) {
-			this.deps.log?.(`automations: run of ${automation.id} failed: ${errorMessage(error)}`);
+			this.deps.log?.(`automations: run of ${automation.id} failed: ${errorMessage$1(error)}`);
 			return {
 				status: "started",
 				run: this.deps.runs.save({
 					...run,
 					status: "failed",
 					finishedAt: this.deps.now().toISOString(),
-					error: { message: errorMessage(error) }
+					error: { message: errorMessage$1(error) }
 				}),
 				sessionId: null
 			};
@@ -44397,7 +45216,7 @@ var CronScheduler = class {
 					else if (pair.automation.guards.catchUpMissed) await this.deps.fire(pair, "catch_up");
 					else this.deps.log?.(`automations: missed ${pair.automation.id} at ${at} (no catch-up)`);
 				} catch (error) {
-					this.deps.log?.(`automations: ${pair.automation.id} failed to fire: ${errorMessage(error)}`);
+					this.deps.log?.(`automations: ${pair.automation.id} failed to fire: ${errorMessage$1(error)}`);
 				}
 			}
 		} finally {
@@ -44922,7 +45741,7 @@ var AutomationService = class {
 			this.syncSessions(events);
 			this.dispatch(events);
 		} catch (error) {
-			this.deps.log?.(`automations: ${errorMessage(error)}`);
+			this.deps.log?.(`automations: ${errorMessage$1(error)}`);
 		}
 	}
 	syncSessions(events) {
@@ -44963,7 +45782,7 @@ var AutomationService = class {
 				this.fire({
 					...req,
 					issue: event.issue
-				}).catch((error) => this.deps.log?.(`automations: event run of ${automation.id}: ${errorMessage(error)}`));
+				}).catch((error) => this.deps.log?.(`automations: event run of ${automation.id}: ${errorMessage$1(error)}`));
 			}
 		}
 	}
@@ -45565,7 +46384,7 @@ async function runAudit(ctx, command, cwd) {
 	} catch (error) {
 		return {
 			ok: false,
-			detail: errorMessage(error)
+			detail: errorMessage$1(error)
 		};
 	}
 }
@@ -45746,7 +46565,7 @@ async function advanceWatching(ctx, project, loop, item) {
 	} catch (error) {
 		ctx.store.updateItem(item.id, (i) => ({
 			...i,
-			note: `Could not read main CI: ${errorMessage(error)}`
+			note: `Could not read main CI: ${errorMessage$1(error)}`
 		}));
 		return loop;
 	}
@@ -45780,7 +46599,7 @@ async function regression(ctx, project, loop, item) {
 		prNumber,
 		title: item.title
 	}).catch((error) => {
-		ctx.log?.(`factory: revert via API: ${errorMessage(error)}`);
+		ctx.log?.(`factory: revert via API: ${errorMessage$1(error)}`);
 		return null;
 	});
 	const base = {
@@ -46105,7 +46924,7 @@ async function advanceVerifying(ctx, project, loop, item) {
 	} catch (error) {
 		ctx.store.updateItem(item.id, (i) => ({
 			...i,
-			note: `Could not read the PR: ${errorMessage(error)}`
+			note: `Could not read the PR: ${errorMessage$1(error)}`
 		}));
 		return loop;
 	}
@@ -46182,7 +47001,7 @@ async function advanceVerifying(ctx, project, loop, item) {
 	}).catch((error) => ({
 		merged: false,
 		sha: null,
-		error: errorMessage(error)
+		error: errorMessage$1(error)
 	}));
 	if (!res.merged) {
 		const why = "error" in res ? res.error : "GitHub did not merge it";
@@ -46206,7 +47025,7 @@ async function advanceVerifying(ctx, project, loop, item) {
 	}));
 	if (current.issue && current.source !== "revert") {
 		const passed = checks.filter((c) => c.state === "pass").map((c) => c.name).join(", ");
-		await ctx.github.comment(project.id, current.issue.number, `Merged automatically by the CodeDen factory in #${pr.ref.number} after every merge check passed (${passed}).`).catch((error) => ctx.log?.(`factory: comment: ${errorMessage(error)}`));
+		await ctx.github.comment(project.id, current.issue.number, `Merged automatically by the CodeDen factory in #${pr.ref.number} after every merge check passed (${passed}).`).catch((error) => ctx.log?.(`factory: comment: ${errorMessage$1(error)}`));
 	}
 	factoryNotice(ctx, {
 		id: `factory.merged:${current.id}`,
@@ -46335,7 +47154,7 @@ async function handleFailure(ctx, project, loop, item) {
 		return loop;
 	}
 	const next = failItem(ctx, loop, item, failed.map((c) => `${c.name}: ${c.detail ?? "failed"}`).join("; ") || "Merge checks failed");
-	if (item.pr) await ctx.github.comment(project.id, item.pr.number, `The CodeDen factory's merge checks failed, so this PR is left for a human:\n\n${failed.map((c) => `- **${c.name}**: ${c.detail ?? "failed"}`).join("\n")}`).catch((error) => ctx.log?.(`factory: comment: ${errorMessage(error)}`));
+	if (item.pr) await ctx.github.comment(project.id, item.pr.number, `The CodeDen factory's merge checks failed, so this PR is left for a human:\n\n${failed.map((c) => `- **${c.name}**: ${c.detail ?? "failed"}`).join("\n")}`).catch((error) => ctx.log?.(`factory: comment: ${errorMessage$1(error)}`));
 	return next;
 }
 // ../server/src/services/factory/loop.ts
@@ -46398,10 +47217,10 @@ async function runTick(ctx, projectId, hooks) {
 		else if (stage === "verifying") loop = await advanceVerifying(ctx, project, loop, item);
 		else loop = await advanceWatching(ctx, project, loop, item);
 	} catch (error) {
-		ctx.log?.(`factory: ${item.id}: ${errorMessage(error)}`);
+		ctx.log?.(`factory: ${item.id}: ${errorMessage$1(error)}`);
 		ctx.store.updateItem(item.id, (i) => ({
 			...i,
-			note: `Loop error: ${errorMessage(error)}`
+			note: `Loop error: ${errorMessage$1(error)}`
 		}));
 	}
 	if (loop.state !== "paused") {
@@ -46528,7 +47347,7 @@ async function discover(ctx, project, loop, now) {
 			startedAt: now.toISOString()
 		});
 	} catch (error) {
-		ctx.log?.(`factory: discovery ${area}: ${errorMessage(error)}`);
+		ctx.log?.(`factory: discovery ${area}: ${errorMessage$1(error)}`);
 	}
 	return {
 		...loop,
@@ -46592,7 +47411,7 @@ async function startBuilder(ctx, item, vision, loop) {
 	} catch (error) {
 		ctx.store.updateItem(item.id, (i) => ({
 			...i,
-			note: `Build not started: ${errorMessage(error)}`
+			note: `Build not started: ${errorMessage$1(error)}`
 		}));
 	}
 }
@@ -46667,7 +47486,7 @@ async function triage(ctx, projectId, req) {
 			score: req.score ?? i.score,
 			finishedAt: at
 		}));
-		if (item.issue) await ctx.github.comment(projectId, item.issue.number, `The CodeDen factory is not taking this on: ${req.reason}`).catch((error) => ctx.log?.(`factory: comment: ${errorMessage(error)}`));
+		if (item.issue) await ctx.github.comment(projectId, item.issue.number, `The CodeDen factory is not taking this on: ${req.reason}`).catch((error) => ctx.log?.(`factory: comment: ${errorMessage$1(error)}`));
 		return rejected;
 	}
 	const criteria = req.acceptanceCriteria ?? item.acceptanceCriteria;
@@ -46675,7 +47494,7 @@ async function triage(ctx, projectId, req) {
 	let issue = item.issue;
 	if (issue) {
 		await ctx.github.labelIssue(projectId, issue.number, [FACTORY_LABEL]).catch(() => void 0);
-		await ctx.github.comment(projectId, issue.number, `Accepted by the CodeDen factory. Acceptance criteria:\n${criteria.map((c) => `- [ ] ${c}`).join("\n")}`).catch((error) => ctx.log?.(`factory: comment: ${errorMessage(error)}`));
+		await ctx.github.comment(projectId, issue.number, `Accepted by the CodeDen factory. Acceptance criteria:\n${criteria.map((c) => `- [ ] ${c}`).join("\n")}`).catch((error) => ctx.log?.(`factory: comment: ${errorMessage$1(error)}`));
 	} else issue = await ctx.github.createIssue(projectId, {
 		title: item.title,
 		body: issueBody(item, criteria),
@@ -46929,7 +47748,7 @@ var FactorySessions = class {
 				await this.deps.sessions.stop(s.id);
 				stopped.push(s.id);
 			} catch (error) {
-				this.deps.log?.(`factory: stop ${s.id}: ${errorMessage(error)}`);
+				this.deps.log?.(`factory: stop ${s.id}: ${errorMessage$1(error)}`);
 			}
 		}
 		return stopped;
@@ -47072,7 +47891,7 @@ var FactoryService = class {
 	tick(projectId) {
 		const next = (this.chains.get(projectId) ?? Promise.resolve(void 0)).catch(() => void 0).then(() => runTick(this.ctx, projectId, { digest: (p, l, day) => this.writeDigest(p, l, day) }));
 		this.chains.set(projectId, next);
-		next.catch((error) => this.deps.log?.(`factory: tick ${projectId}: ${errorMessage(error)}`)).finally(() => {
+		next.catch((error) => this.deps.log?.(`factory: tick ${projectId}: ${errorMessage$1(error)}`)).finally(() => {
 			if (this.chains.get(projectId) === next) this.chains.delete(projectId);
 		});
 		return next;
@@ -47083,7 +47902,7 @@ var FactoryService = class {
 		try {
 			projects = this.deps.projects.list();
 		} catch (error) {
-			this.deps.log?.(`factory: listing projects: ${errorMessage(error)}`);
+			this.deps.log?.(`factory: listing projects: ${errorMessage$1(error)}`);
 			return;
 		}
 		for (const p of projects) {
@@ -47126,11 +47945,11 @@ var FactoryService = class {
 				shareError: null
 			};
 		} catch (error) {
-			this.deps.log?.(`factory: committing the vision: ${errorMessage(error)}`);
+			this.deps.log?.(`factory: committing the vision: ${errorMessage$1(error)}`);
 			return {
 				...saved,
 				pr: null,
-				shareError: errorMessage(error)
+				shareError: errorMessage$1(error)
 			};
 		}
 	}
@@ -47623,7 +48442,7 @@ var GithubFactoryPort = class {
 				};
 			});
 		} catch (error) {
-			throw new Error(`checks for ${sha.slice(0, 7)}: ${errorMessage(error)}`);
+			throw new Error(`checks for ${sha.slice(0, 7)}: ${errorMessage$1(error)}`);
 		}
 	}
 };
@@ -51190,7 +52009,7 @@ var GithubClient = class {
 function toGithubError(error) {
 	if (error instanceof ServiceError) return error;
 	const http = httpError(error);
-	if (!http) return new ServiceError(502, "github_error", `GitHub request failed: ${errorMessage(error)}`);
+	if (!http) return new ServiceError(502, "github_error", `GitHub request failed: ${errorMessage$1(error)}`);
 	const headers = http.response?.headers ?? {};
 	const remaining = headers["x-ratelimit-remaining"];
 	const retryAfter = headers["retry-after"];
@@ -51233,7 +52052,7 @@ var PrFollowUp = class {
 			const { pr } = e.payload;
 			if (!pr.sessionId) continue;
 			setImmediate(() => {
-				this.handle(e.type, pr).catch((error) => this.deps.log?.(`github follow-up for PR #${pr.number}: ${errorMessage(error)}`));
+				this.handle(e.type, pr).catch((error) => this.deps.log?.(`github follow-up for PR #${pr.number}: ${errorMessage$1(error)}`));
 			});
 		}
 	}
@@ -51282,7 +52101,7 @@ var PrFollowUp = class {
 			}, 15e3);
 		} catch (error) {
 			const code = runnerErrorCode(error);
-			if (code !== "unknown_session" && code !== "runner_unavailable") this.deps.log?.(`github follow-up: stopping ${sessionId}: ${errorMessage(error)}`);
+			if (code !== "unknown_session" && code !== "runner_unavailable") this.deps.log?.(`github follow-up: stopping ${sessionId}: ${errorMessage$1(error)}`);
 		}
 	}
 	/** Comment on each linked issue that the merged PR resolved it. */
@@ -51794,7 +52613,7 @@ var GithubSync = class {
 			schedule.nextAt = this.now() + schedule.intervalMs;
 		} catch (error) {
 			schedule.failures++;
-			state.lastError = errorMessage(error);
+			state.lastError = errorMessage$1(error);
 			if (error instanceof GithubRateLimitError) schedule.nextAt = Math.max(error.resetAt, this.now() + 6e4);
 			else if (error instanceof GithubNotConnectedError) schedule.nextAt = this.now() + 3e5;
 			else {
@@ -51932,7 +52751,7 @@ var GithubSync = class {
 					};
 				});
 			} catch (error) {
-				this.deps.log?.(`github sync: comments of #${payload.issue.number}: ${errorMessage(error)}`);
+				this.deps.log?.(`github sync: comments of #${payload.issue.number}: ${errorMessage$1(error)}`);
 			}
 		}
 	}
@@ -52043,7 +52862,7 @@ var GithubService = class {
 				try {
 					this.reviewInbox.onEvents(events);
 				} catch (error) {
-					this.deps.log?.(`github: review inbox: ${errorMessage(error)}`);
+					this.deps.log?.(`github: review inbox: ${errorMessage$1(error)}`);
 				}
 			});
 		});
@@ -52082,7 +52901,7 @@ var GithubService = class {
 				token: token.value
 			};
 		} catch (error) {
-			const message = error instanceof ServiceError ? error.message : errorMessage(error);
+			const message = error instanceof ServiceError ? error.message : errorMessage$1(error);
 			return {
 				connected: false,
 				source: token.source,
@@ -52174,7 +52993,7 @@ var GithubService = class {
 			...req.commitTitle ? { commit_title: req.commitTitle } : {},
 			...req.commitMessage ? { commit_message: req.commitMessage } : {}
 		}));
-		await refreshPr(this.prDeps(), projectId, repo, number).catch((error) => this.deps.log?.(`github: refresh after merge: ${errorMessage(error)}`));
+		await refreshPr(this.prDeps(), projectId, repo, number).catch((error) => this.deps.log?.(`github: refresh after merge: ${errorMessage$1(error)}`));
 		return {
 			merged: res.data.merged,
 			sha: res.data.sha ?? null
@@ -52393,7 +53212,7 @@ var ImageService = class {
 			this.checkedAt = Date.now();
 			return available;
 		}).catch((error) => {
-			this.deps.log?.(`images: detection failed: ${errorMessage(error)}`);
+			this.deps.log?.(`images: detection failed: ${errorMessage$1(error)}`);
 			this.available = false;
 			this.checkedAt = Date.now();
 			return false;
@@ -52437,7 +53256,7 @@ var ImageService = class {
 		try {
 			target = resolveImageOutput(root, req.outputPath);
 		} catch (error) {
-			throw badRequest(errorMessage(error), "invalid_output_path");
+			throw badRequest(errorMessage$1(error), "invalid_output_path");
 		}
 		this.assertNoEscape(root, target.outputDir);
 		const references = (req.referenceImages ?? []).map((p) => this.referencePath(cwd, p));
@@ -52587,7 +53406,7 @@ function toServiceError(error) {
 		const retry = error.details.retryAfter ? ` Try again after ${error.details.retryAfter.toISOString()}.` : "";
 		return new ServiceError(error.code === "invalid_request" || error.code === "content_policy" ? 400 : 502, `image_${error.code}`, `${error.message}${retry}`);
 	}
-	return new ServiceError(502, "image_failed", errorMessage(error));
+	return new ServiceError(502, "image_failed", errorMessage$1(error));
 }
 // ../server/src/services/inbox-service.ts
 /** The inbox (§11.1): everything waiting on the user. */
@@ -53611,7 +54430,7 @@ var OrchestrationService = class {
 				text: parts.join("\n\n")
 			};
 		} catch (error) {
-			this.deps.log?.(`orchestration digest: ${errorMessage(error)}`);
+			this.deps.log?.(`orchestration digest: ${errorMessage$1(error)}`);
 			return input;
 		}
 	}
@@ -53727,7 +54546,7 @@ var OrchestrationService = class {
 				}), ...deriveGithubNotices(events, session)];
 				for (const { notice, wake } of derived) this.notify(notice, wake);
 			} catch (error) {
-				this.deps.log?.(`orchestration notices: ${errorMessage(error)}`);
+				this.deps.log?.(`orchestration notices: ${errorMessage$1(error)}`);
 			}
 		});
 	}
@@ -54236,12 +55055,12 @@ var ProjectRedetector = class {
 		try {
 			projects = this.deps.projects.list();
 		} catch (error) {
-			this.deps.log?.(`projects: listing for the start-up check: ${errorMessage(error)}`);
+			this.deps.log?.(`projects: listing for the start-up check: ${errorMessage$1(error)}`);
 			return;
 		}
 		for (const project of projects) {
 			if (this.stopped) return;
-			await this.refresh(project.id).catch((error) => this.deps.log?.(`projects: checking ${project.name}: ${errorMessage(error)}`));
+			await this.refresh(project.id).catch((error) => this.deps.log?.(`projects: checking ${project.name}: ${errorMessage$1(error)}`));
 		}
 	}
 	onEvents(events) {
@@ -54257,7 +55076,7 @@ var ProjectRedetector = class {
 					if (projectId) projectIds.add(projectId);
 				}
 			} catch (error) {
-				this.deps.log?.(`projects: after a turn: ${errorMessage(error)}`);
+				this.deps.log?.(`projects: after a turn: ${errorMessage$1(error)}`);
 				return;
 			}
 			for (const projectId of projectIds) this.afterTurn(projectId);
@@ -54276,7 +55095,7 @@ var ProjectRedetector = class {
 			this.again.add(projectId);
 			return;
 		}
-		this.refresh(projectId).catch((error) => this.deps.log?.(`projects: checking ${projectId}: ${errorMessage(error)}`));
+		this.refresh(projectId).catch((error) => this.deps.log?.(`projects: checking ${projectId}: ${errorMessage$1(error)}`));
 	}
 };
 // ../server/src/services/orchestration/prompts.ts
@@ -54461,7 +55280,7 @@ var SessionLauncher = class {
 	}
 	/** Mark a session failed with an inbox item explaining why. */
 	fail(sessionId, key, error) {
-		const message = errorMessage(error);
+		const message = errorMessage$1(error);
 		this.deps.log?.(`session ${sessionId}: ${message}`);
 		if (!this.deps.repo.find(sessionId)) return;
 		const session = this.deps.repo.update(sessionId, (s) => s.status === "stopped" ? s : {
@@ -54645,7 +55464,7 @@ var SessionLifecycle = class {
 				title
 			});
 		} catch (error) {
-			this.deps.log?.(`utility title: ${errorMessage(error)}`);
+			this.deps.log?.(`utility title: ${errorMessage$1(error)}`);
 		} finally {
 			this.titling.delete(sessionId);
 		}
@@ -54658,7 +55477,7 @@ var SessionLifecycle = class {
 			try {
 				this.drainQueue();
 			} catch (error) {
-				this.deps.log?.(`queue: ${errorMessage(error)}`);
+				this.deps.log?.(`queue: ${errorMessage$1(error)}`);
 			}
 		});
 	}
@@ -54701,7 +55520,7 @@ var SessionLifecycle = class {
 				})]);
 			}
 		} catch (error) {
-			this.deps.log?.(`utility hooks: ${errorMessage(error)}`);
+			this.deps.log?.(`utility hooks: ${errorMessage$1(error)}`);
 		}
 	}
 };
@@ -55021,7 +55840,7 @@ var SessionRecovery = class {
 			const status = await runner.request({ name: "runner.status" }, 1e4);
 			hosted = new Set(status.sessions.map((s) => s.sessionId));
 		} catch (error) {
-			log?.(`recovery: runner status failed: ${errorMessage(error)}`);
+			log?.(`recovery: runner status failed: ${errorMessage$1(error)}`);
 			return;
 		}
 		for (const id of candidates) {
@@ -55808,7 +56627,7 @@ var WorktreeCleanup = class {
 				force: opts.force
 			}, REMOVE_TIMEOUT_MS)).discardedChanges === true;
 		} catch (error) {
-			const message = errorMessage(error);
+			const message = errorMessage$1(error);
 			if (runnerErrorCode(error) === "worktree_dirty" || /modified or untracked/.test(message)) return outcome("kept_changes", "The worktree has uncommitted changes, so it was kept");
 			this.deps.log?.(`worktree cleanup: could not remove ${session.worktreePath}: ${message}`);
 			return outcome("failed", message);
@@ -55845,7 +56664,7 @@ var WorktreeCleanup = class {
 				else if (result.status === "kept_changes") this.kept.set(session.id, this.deps.repo.get(session.id).updatedAt);
 			}
 		} catch (error) {
-			this.deps.log?.(`worktree cleanup failed: ${errorMessage(error)}`);
+			this.deps.log?.(`worktree cleanup failed: ${errorMessage$1(error)}`);
 		} finally {
 			this.sweeping = false;
 		}
@@ -55867,7 +56686,7 @@ var WorktreeCleanup = class {
 		for (const e of events) {
 			if (e.type !== "project.archived") continue;
 			const projectId = e.payload.projectId;
-			if (typeof projectId === "string") this.cleanProject(projectId).catch((error) => this.deps.log?.(`worktree cleanup for project ${projectId}: ${errorMessage(error)}`));
+			if (typeof projectId === "string") this.cleanProject(projectId).catch((error) => this.deps.log?.(`worktree cleanup for project ${projectId}: ${errorMessage$1(error)}`));
 		}
 	}
 	now() {
@@ -55922,7 +56741,7 @@ var ClaudeSdkService = class {
 				this.progress = line;
 			}
 		}).then(() => importClaudeSdkFrom(this.deps.depsDir)).then(() => this.deps.log?.(`Claude Code support installed (${CLAUDE_SDK_VERSION})`), (error) => {
-			this.error = errorMessage(error);
+			this.error = errorMessage$1(error);
 			this.deps.log?.(`Claude Code support install failed: ${this.error}`);
 		}).finally(() => {
 			this.running = void 0;
@@ -56476,7 +57295,7 @@ var SetupService = class {
 				authMethod: null,
 				account: null,
 				loginExpiresAt: null,
-				message: `Check failed: ${errorMessage(error)}`,
+				message: `Check failed: ${errorMessage$1(error)}`,
 				fix: null,
 				durationMs: Math.max(0, this.now() - started)
 			};
@@ -56708,7 +57527,7 @@ var DesktopUpdateService = class {
 			await this.deps.desktop.run("check");
 			this.installFailed = false;
 		} catch (error) {
-			this.deps.log?.(`updates: check failed: ${errorMessage(error)}`);
+			this.deps.log?.(`updates: check failed: ${errorMessage$1(error)}`);
 		}
 		this.emit();
 	}
@@ -56717,7 +57536,7 @@ var DesktopUpdateService = class {
 		this.deps.desktop.run(command).catch((error) => {
 			this.installFailed = true;
 			this.restartWhenDownloaded = false;
-			this.deps.log?.(`updates: ${command} failed: ${errorMessage(error)}`);
+			this.deps.log?.(`updates: ${command} failed: ${errorMessage$1(error)}`);
 			this.emit();
 		});
 	}
@@ -57040,7 +57859,7 @@ var UpdateService = class {
 			this.latest = await fetchLatestVersion(this.deps.registry, this.deps.fetch);
 			this.error = null;
 		} catch (error) {
-			this.error = errorMessage(error);
+			this.error = errorMessage$1(error);
 			this.deps.log?.(`updates: ${this.error}`);
 		} finally {
 			this.checkedAt = this.now();
@@ -57076,7 +57895,7 @@ var UpdateService = class {
 			else this.emit();
 		} catch (error) {
 			this.state = "failed";
-			this.installError = errorMessage(error);
+			this.installError = errorMessage$1(error);
 			this.progress = null;
 			this.deps.log?.(`updates: install failed: ${this.installError}`);
 			this.emit();
@@ -58838,7 +59657,7 @@ var LocalSttService = class {
 				};
 			} catch (error) {
 				if (opts.signal?.aborted) throw new ServiceError(400, "aborted", "Cancelled");
-				throw new ServiceError(500, "transcription_failed", errorMessage(error));
+				throw new ServiceError(500, "transcription_failed", errorMessage$1(error));
 			} finally {
 				this.armIdleUnload();
 			}
@@ -58895,8 +59714,8 @@ var LocalSttService = class {
 			job.received = received;
 		}).catch((error) => {
 			if (!abort.signal.aborted) {
-				this.errors.set(key, errorMessage(error));
-				this.deps.log?.(`Whisper download (${key}) failed: ${errorMessage(error)}`);
+				this.errors.set(key, errorMessage$1(error));
+				this.deps.log?.(`Whisper download (${key}) failed: ${errorMessage$1(error)}`);
 			}
 			throw error;
 		}).finally(() => this.jobs.delete(key));
@@ -59377,18 +60196,51 @@ async function startServer(opts) {
 	services.worktreeCleanup.start();
 	const stopUpdateEvents = services.updates.onChange((status) => hub.broadcastUpdate(status));
 	services.updates.start();
-	let origins = /* @__PURE__ */ new Set();
+	let baseOrigins = /* @__PURE__ */ new Set();
 	const app = new Hono();
+	const wss = new import_websocket_server.default({ noServer: true });
+	const httpServer = createAdaptorServer({
+		fetch: app.fetch,
+		websocket: { server: wss }
+	});
+	const listener = new HttpListener(httpServer);
+	const network = new NetworkAccess({
+		store: new RemoteAccessStore(paths.remoteAccess),
+		listener,
+		interfaces: opts.networkInterfaces,
+		securityLogFile: paths.remoteAccessLog,
+		log
+	});
+	const sessionCookie = () => `codeden_session_${port}`;
+	const tokenCookie = () => `codeden_token_${port}`;
+	const allowedOrigins = () => {
+		const own = [...network.ownHosts()].map((h) => `http://${h}:${port}`);
+		return own.length === 0 ? baseOrigins : /* @__PURE__ */ new Set([...baseOrigins, ...own]);
+	};
 	app.use("*", securityMiddleware({
 		token: opts.token,
-		cookieName: () => `codeden_token_${port}`,
-		allowedOrigins: () => origins,
-		publicPaths: /* @__PURE__ */ new Set(["/api/health", "/mcp"])
+		cookieName: tokenCookie,
+		allowedOrigins,
+		publicPaths: /* @__PURE__ */ new Set(["/api/health", "/mcp"]),
+		loopbackOnlyPaths: /* @__PURE__ */ new Set(["/mcp"]),
+		remote: {
+			enabled: () => network.enabled,
+			ownHosts: () => network.ownHosts(),
+			port: () => port,
+			sessionCookieName: sessionCookie,
+			verifySession: (token) => network.store.verifySession(token)
+		}
 	}));
 	const api = createApi({
 		services,
 		runnerStatus,
 		startedAt,
+		network: {
+			network,
+			sessionCookie,
+			tokenCookie,
+			token: opts.token
+		},
 		log,
 		shutdown: ({ stopRunner }) => {
 			setTimeout(() => {
@@ -59438,18 +60290,9 @@ async function startServer(opts) {
 		return upgradeWebSocket(() => browserBridge.handlers(query.data))(c, next);
 	});
 	mountWeb(app, findWebDir(opts.webDir));
-	const wss = new import_websocket_server.default({ noServer: true });
-	const server = await new Promise((resolve, reject) => {
-		const s = serve({
-			fetch: app.fetch,
-			port: opts.port,
-			hostname: "127.0.0.1",
-			websocket: { server: wss }
-		}, () => resolve(s));
-		s.once("error", reject);
-	});
-	port = server.address().port;
-	origins = /* @__PURE__ */ new Set([...loopbackOrigins(port), ...opts.allowedOrigins ?? []]);
+	if (network.store.enabled && !network.store.passwordSet) log("network access is on but no password is set: listening on 127.0.0.1 only");
+	port = await listener.listen(opts.port, network.desiredHost());
+	baseOrigins = /* @__PURE__ */ new Set([...loopbackOrigins(port), ...opts.allowedOrigins ?? []]);
 	const url = `http://127.0.0.1:${port}`;
 	const lock = {
 		pid: process.pid,
@@ -59459,6 +60302,7 @@ async function startServer(opts) {
 	};
 	writeJsonFile(paths.serverLock, lock);
 	log(`server listening on ${url}`);
+	if (network.enabled) log(`network access on: ${network.addresses().map((a) => `${a.label} ${a.url}`).join(", ")}`);
 	if (opts.checkSetupOnStart !== false) services.setup.status({ refresh: true }).catch((error) => log(`setup: ${String(error)}`));
 	if (opts.runner !== false) {
 		const args = [...opts.enableFakeProvider ? ["--fake"] : [], ...builtin ? [] : ["--no-builtin"]];
@@ -59503,10 +60347,8 @@ async function startServer(opts) {
 			}
 			hub.close();
 			wss.close();
-			await new Promise((resolve) => {
-				server.close(() => resolve());
-				if ("closeAllConnections" in server) server.closeAllConnections();
-			});
+			await listener.close();
+			if ("closeAllConnections" in httpServer) httpServer.closeAllConnections();
 			database.close();
 			rmSync(paths.serverLock, { force: true });
 		})();
@@ -59521,6 +60363,7 @@ async function startServer(opts) {
 		database,
 		services,
 		runner,
+		network,
 		close
 	};
 }
@@ -59719,6 +60562,147 @@ function versionRows(home, launch) {
 	}
 	return rows;
 }
+// src/network-command.ts
+const DEFAULT_PORT$1 = 4317;
+/** Call the running server's network API over loopback with the install token. */
+async function callServer(home, path, init) {
+	const paths = ensureHome(home);
+	const running = await findRunningServer(paths.serverLock);
+	if (!running) return void 0;
+	const token = ensureInstallToken(paths.token);
+	const res = await fetch(`http://127.0.0.1:${running.port}${path}`, {
+		method: init.method,
+		headers: {
+			authorization: `Bearer ${token}`,
+			"content-type": "application/json"
+		},
+		body: init.body === void 0 ? void 0 : JSON.stringify(init.body)
+	});
+	return {
+		ok: res.ok,
+		status: res.status,
+		body: await res.json().catch(() => null)
+	};
+}
+function errorMessage(body) {
+	const message = body?.error?.message;
+	return typeof message === "string" ? message : "The server refused the request.";
+}
+function printAddresses(addresses) {
+	for (const a of addresses) console.log(`  ${a.label.padEnd(16)} ${a.url}`);
+}
+/** Ask for a line without echoing it (a TTY), or read the first line of piped input. */
+async function readSecret(question) {
+	const tty = process.stdin.isTTY === true;
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout,
+		terminal: tty
+	});
+	if (tty) {
+		process.stdout.write(question);
+		rl._writeToOutput = () => {};
+	}
+	return new Promise((resolve) => {
+		rl.once("line", (line) => {
+			if (tty) process.stdout.write("\n");
+			rl.close();
+			resolve(line);
+		});
+		rl.once("close", () => resolve(""));
+	});
+}
+/**
+* `codeden password [--generate]`: set the network-access password (signs out every remote
+* device). Through the running server when there is one, else straight into the home.
+*/
+async function passwordCommand(home, opts) {
+	let password = null;
+	if (!opts.generate) {
+		console.log(PASSWORD_RULE_TEXT);
+		password = await readSecret("New password: ");
+		const problem = passwordProblem(password);
+		if (problem) {
+			console.error(problem);
+			return 1;
+		}
+		if (process.stdin.isTTY && await readSecret("Repeat it: ") !== password) {
+			console.error("The two passwords don't match.");
+			return 1;
+		}
+	}
+	const viaServer = await callServer(home, "/api/network/password", {
+		method: "POST",
+		body: password === null ? { generate: true } : { password }
+	});
+	let generated;
+	if (viaServer) {
+		if (!viaServer.ok) {
+			console.error(errorMessage(viaServer.body));
+			return 1;
+		}
+		generated = SetNetworkPasswordResponse.parse(viaServer.body).generated;
+	} else {
+		const store = new RemoteAccessStore(ensureHome(home).remoteAccess);
+		generated = password === null ? generatePassphrase() : null;
+		try {
+			await store.setPassword(generated ?? password);
+		} catch (error) {
+			if (error instanceof PasswordRuleError) {
+				console.error(error.message);
+				return 1;
+			}
+			throw error;
+		}
+	}
+	if (generated) {
+		console.log("Your network access password (shown once, keep it somewhere safe):");
+		console.log(`  ${generated}`);
+	}
+	console.log("Password saved. Every remote device was signed out.");
+	return 0;
+}
+/** `codeden network [on|off]`: switch network access, or show its state. */
+async function networkCommand(home, action) {
+	if (action !== void 0 && action !== "on" && action !== "off") {
+		console.error("Usage: codeden network [on|off]");
+		return 2;
+	}
+	const viaServer = await callServer(home, "/api/network", action === void 0 ? { method: "GET" } : {
+		method: "PUT",
+		body: { enabled: action === "on" }
+	});
+	if (viaServer) {
+		if (!viaServer.ok) {
+			console.error(errorMessage(viaServer.body));
+			if (viaServer.status === 400) console.error("Run: codeden password");
+			return 1;
+		}
+		const status = NetworkStatus.parse(viaServer.body);
+		if (status.enabled) {
+			console.log("Network access is on. Open CodeDen on your phone at:");
+			printAddresses(status.addresses);
+		} else console.log("Network access is off: CodeDen only answers on this computer (127.0.0.1).");
+		return 0;
+	}
+	const store = new RemoteAccessStore(ensureHome(home).remoteAccess);
+	if (action === void 0) {
+		console.log(`Network access is ${store.enabled && store.passwordSet ? "on" : "off"} (CodeDen is not running).`);
+		return 0;
+	}
+	try {
+		store.setEnabled(action === "on");
+	} catch (error) {
+		console.error(error instanceof Error ? error.message : String(error));
+		console.error("Run: codeden password");
+		return 1;
+	}
+	if (action === "on") {
+		console.log("Network access is on. When CodeDen starts it will answer on:");
+		printAddresses(listAddresses(DEFAULT_PORT$1));
+	} else console.log("Network access is off.");
+	return 0;
+}
 // src/open-browser.ts
 /** Open a URL in the default browser without a shell (no quoting pitfalls). */
 function openBrowser(url) {
@@ -60071,6 +61055,8 @@ async function viaServer(port, token, rollback) {
 *   codeden doctor [--install]
 *   codeden update [--rollback]
 *   codeden stop
+*   codeden password [--generate]
+*   codeden network [on|off]
 * Loaded by `cli.ts` once the launcher has picked the version to run.
 */
 const DEFAULT_PORT = 4317;
@@ -60081,6 +61067,8 @@ Usage:
   codeden doctor         Check the installation (--install: add Claude Code support now)
   codeden update         Install the latest version and switch to it (--rollback: go back)
   codeden stop           Stop the server and the runner
+  codeden password       Set the network access password (--generate: make one up)
+  codeden network on|off Let phones on your network open CodeDen, or stop it
 
 Options:
   --port <n>     Port to listen on (default ${DEFAULT_PORT})
@@ -60121,6 +61109,10 @@ async function main() {
 				type: "boolean",
 				default: false
 			},
+			generate: {
+				type: "boolean",
+				default: false
+			},
 			version: {
 				type: "boolean",
 				short: "v",
@@ -60157,6 +61149,8 @@ async function main() {
 		rollback: values.rollback,
 		launch
 	});
+	if (command === "password") return passwordCommand(home, { generate: values.generate });
+	if (command === "network") return networkCommand(home, positionals[1]);
 	if (command) {
 		console.error(`Unknown command "${command}".\n\n${HELP}`);
 		return 2;
@@ -60216,6 +61210,10 @@ async function main() {
 	}
 	console.log(`CodeDen ${CODEDEN_VERSION} is running at ${server.url}`);
 	console.log(`Open: ${server.launchUrl}`);
+	if (server.network.enabled) {
+		console.log("Network access is on. Open CodeDen on your phone or tablet at:");
+		for (const a of server.network.addresses()) console.log(`  ${a.label.padEnd(16)} ${a.url}`);
+	}
 	console.log("Press Ctrl+C to stop the server (agents keep running in the runner).");
 	if (!values["no-open"]) openBrowser(server.launchUrl);
 	process.on("SIGINT", shutdown);
@@ -60228,4 +61226,4 @@ main().then((code) => process.exit(code), (error) => {
 });
 export {};
 
-//# sourceMappingURL=main-BAX1sPiD.js.map
+//# sourceMappingURL=main-f5CBW7t4.js.map