very-happy-cli 0.2.159 → 0.2.161

package/dist/persistence-oET5n61f.mjs

@@ -0,0 +1,372 @@
+import { readFile, open, unlink, stat, rename } from 'node:fs/promises';
+import { existsSync, constants, readFileSync, unlinkSync, renameSync } from 'node:fs';
+import { c as configuration, P as PRIVATE_FILE_MODE, w as writePrivateFileSync, h as hardenPrivateFileSync, e as ensurePrivateDirectory, a as writePrivateFile, b as hardenPrivateFile } from './configuration-DoWFJUPm.mjs';
+import * as z from 'zod';
+import { c as credentialRelayProblem, e as encodeBase64 } from './authRelay-DSAvg1uv.mjs';
+import { l as logger } from './logger-fXoNzNuB.mjs';
+import 'node:os';
+import 'node:path';
+import './package-uOg9SCKi.mjs';
+import 'node:crypto';
+import 'tweetnacl';
+import 'chalk';
+import 'node:util';
+
+const SandboxConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  workspaceRoot: z.string().optional(),
+  sessionIsolation: z.enum(["strict", "workspace", "custom"]).default("workspace"),
+  customWritePaths: z.array(z.string()).default([]),
+  denyReadPaths: z.array(z.string()).default(["~/.ssh", "~/.aws", "~/.gnupg"]),
+  extraWritePaths: z.array(z.string()).default(["/tmp"]),
+  denyWritePaths: z.array(z.string()).default([".env"]),
+  networkMode: z.enum(["blocked", "allowed", "custom"]).default("allowed"),
+  allowedDomains: z.array(z.string()).default([]),
+  deniedDomains: z.array(z.string()).default([]),
+  allowLocalBinding: z.boolean().default(true)
+});
+const SUPPORTED_SCHEMA_VERSION = 2;
+const defaultSettings = {
+  schemaVersion: SUPPORTED_SCHEMA_VERSION,
+  onboardingCompleted: false,
+  sandboxConfig: void 0
+};
+function migrateSettings(raw, fromVersion) {
+  let migrated = { ...raw };
+  return migrated;
+}
+async function readSettingsOutcome() {
+  if (!existsSync(configuration.settingsFile)) {
+    return { kind: "absent" };
+  }
+  try {
+    return { kind: "ok", settings: await parseSettingsFile() };
+  } catch (error) {
+    return { kind: "unreadable", error: error?.message ?? String(error) };
+  }
+}
+async function readSettings() {
+  const outcome = await readSettingsOutcome();
+  if (outcome.kind === "ok") return outcome.settings;
+  if (outcome.kind === "unreadable") {
+    logger.warn(`Failed to read settings: ${outcome.error}`);
+  }
+  return { ...defaultSettings };
+}
+async function parseSettingsFile() {
+  const content = await readFile(configuration.settingsFile, "utf8");
+  const raw = JSON.parse(content);
+  const schemaVersion = raw.schemaVersion ?? 1;
+  if (schemaVersion > SUPPORTED_SCHEMA_VERSION) {
+    logger.warn(
+      `\u26A0\uFE0F Settings schema v${schemaVersion} > supported v${SUPPORTED_SCHEMA_VERSION}. Update happy-cli for full functionality.`
+    );
+  }
+  const migrated = migrateSettings(raw);
+  if (migrated.sandboxConfig !== void 0) {
+    try {
+      migrated.sandboxConfig = SandboxConfigSchema.parse(migrated.sandboxConfig);
+    } catch (error) {
+      logger.warn(`\u26A0\uFE0F Invalid sandbox config - skipping. Error: ${error.message}`);
+      migrated.sandboxConfig = void 0;
+    }
+  }
+  return { ...defaultSettings, ...migrated };
+}
+async function writeSettings(settings) {
+  await ensurePrivateDirectory(configuration.happyHomeDir);
+  const settingsWithVersion = {
+    ...settings,
+    schemaVersion: settings.schemaVersion ?? SUPPORTED_SCHEMA_VERSION
+  };
+  await writePrivateFile(configuration.settingsFile, JSON.stringify(settingsWithVersion, null, 2));
+}
+async function updateSettings(updater) {
+  const LOCK_RETRY_INTERVAL_MS = 100;
+  const MAX_LOCK_ATTEMPTS = 50;
+  const STALE_LOCK_TIMEOUT_MS = 1e4;
+  const lockFile = configuration.settingsFile + ".lock";
+  const tmpFile = configuration.settingsFile + ".tmp";
+  let fileHandle;
+  let attempts = 0;
+  while (attempts < MAX_LOCK_ATTEMPTS) {
+    try {
+      fileHandle = await open(lockFile, constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY, PRIVATE_FILE_MODE);
+      break;
+    } catch (err) {
+      if (err.code === "EEXIST") {
+        attempts++;
+        await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_INTERVAL_MS));
+        try {
+          const stats = await stat(lockFile);
+          if (Date.now() - stats.mtimeMs > STALE_LOCK_TIMEOUT_MS) {
+            await unlink(lockFile).catch(() => {
+            });
+          }
+        } catch {
+        }
+      } else {
+        throw err;
+      }
+    }
+  }
+  if (!fileHandle) {
+    throw new Error(`Failed to acquire settings lock after ${MAX_LOCK_ATTEMPTS * LOCK_RETRY_INTERVAL_MS / 1e3} seconds`);
+  }
+  try {
+    const outcome = await readSettingsOutcome();
+    if (outcome.kind === "unreadable") {
+      throw new Error(
+        `Settings file ${configuration.settingsFile} exists but could not be read (${outcome.error}). Refusing to overwrite it \u2014 fix or remove the file (a removed file is recreated with defaults).`
+      );
+    }
+    const current = outcome.kind === "ok" ? outcome.settings : { ...defaultSettings };
+    const updated = await updater(current);
+    await ensurePrivateDirectory(configuration.happyHomeDir);
+    await writePrivateFile(tmpFile, JSON.stringify(updated, null, 2));
+    await rename(tmpFile, configuration.settingsFile);
+    await hardenPrivateFile(configuration.settingsFile);
+    return updated;
+  } finally {
+    await fileHandle.close();
+    await unlink(lockFile).catch(() => {
+    });
+  }
+}
+const credentialsSchema = z.object({
+  token: z.string(),
+  authServerUrl: z.string().optional(),
+  secret: z.string().base64().nullish(),
+  // Legacy
+  encryption: z.object({
+    publicKey: z.string().base64(),
+    machineKey: z.string().base64()
+  }).nullish()
+});
+async function readCredentials() {
+  if (!existsSync(configuration.privateKeyFile)) {
+    return null;
+  }
+  try {
+    const keyBase64 = await readFile(configuration.privateKeyFile, "utf8");
+    const credentials = credentialsSchema.parse(JSON.parse(keyBase64));
+    if (credentials.secret) {
+      return {
+        token: credentials.token,
+        authServerUrl: credentials.authServerUrl,
+        encryption: {
+          type: "legacy",
+          secret: new Uint8Array(Buffer.from(credentials.secret, "base64"))
+        }
+      };
+    } else if (credentials.encryption) {
+      return {
+        token: credentials.token,
+        authServerUrl: credentials.authServerUrl,
+        encryption: {
+          type: "dataKey",
+          publicKey: new Uint8Array(Buffer.from(credentials.encryption.publicKey, "base64")),
+          machineKey: new Uint8Array(Buffer.from(credentials.encryption.machineKey, "base64"))
+        }
+      };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+async function readCredentialsForConfiguredRelay() {
+  const credentials = await readCredentials();
+  if (!credentials) return null;
+  const relayProblem = credentialRelayProblem(credentials.authServerUrl, configuration.serverUrl);
+  if (relayProblem) {
+    throw new Error(
+      `${relayProblem} Use a separate HAPPY_HOME_DIR for this relay, or run \`very-happy auth login --force\` before making relay requests.`
+    );
+  }
+  return credentials;
+}
+async function writeCredentialsLegacy(credentials) {
+  await ensurePrivateDirectory(configuration.happyHomeDir);
+  await writePrivateFile(configuration.privateKeyFile, JSON.stringify({
+    secret: encodeBase64(credentials.secret),
+    token: credentials.token,
+    authServerUrl: configuration.serverUrl
+  }, null, 2));
+}
+async function writeCredentialsDataKey(credentials) {
+  await ensurePrivateDirectory(configuration.happyHomeDir);
+  await writePrivateFile(configuration.privateKeyFile, JSON.stringify({
+    encryption: { publicKey: encodeBase64(credentials.publicKey), machineKey: encodeBase64(credentials.machineKey) },
+    token: credentials.token,
+    authServerUrl: configuration.serverUrl
+  }, null, 2));
+}
+async function clearCredentials() {
+  if (existsSync(configuration.privateKeyFile)) {
+    await unlink(configuration.privateKeyFile);
+  }
+}
+async function clearMachineId() {
+  await updateSettings((settings) => ({
+    ...settings,
+    machineId: void 0
+  }));
+}
+async function readDaemonState() {
+  try {
+    if (!existsSync(configuration.daemonStateFile)) {
+      return null;
+    }
+    const content = await readFile(configuration.daemonStateFile, "utf-8");
+    return JSON.parse(content);
+  } catch (error) {
+    console.error(`[PERSISTENCE] Daemon state file corrupted: ${configuration.daemonStateFile}`, error);
+    return null;
+  }
+}
+function writeDaemonState(state) {
+  writePrivateFileSync(configuration.daemonStateFile, JSON.stringify(state, null, 2));
+}
+async function clearDaemonState() {
+  if (existsSync(configuration.daemonStateFile)) {
+    await unlink(configuration.daemonStateFile);
+  }
+  if (existsSync(configuration.daemonLockFile)) {
+    try {
+      await unlink(configuration.daemonLockFile);
+    } catch {
+    }
+  }
+}
+async function acquireDaemonLock(maxAttempts = 5, delayIncrementMs = 200) {
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      const fileHandle = await open(
+        configuration.daemonLockFile,
+        constants.O_CREAT | constants.O_EXCL | constants.O_WRONLY,
+        PRIVATE_FILE_MODE
+      );
+      await fileHandle.writeFile(String(process.pid));
+      return fileHandle;
+    } catch (error) {
+      if (error.code === "EEXIST") {
+        try {
+          const lockPid = readFileSync(configuration.daemonLockFile, "utf-8").trim();
+          if (lockPid && !isNaN(Number(lockPid))) {
+            try {
+              process.kill(Number(lockPid), 0);
+            } catch {
+              unlinkSync(configuration.daemonLockFile);
+              continue;
+            }
+          }
+        } catch {
+        }
+      }
+      if (attempt === maxAttempts) {
+        return null;
+      }
+      const delayMs = attempt * delayIncrementMs;
+      await new Promise((resolve) => setTimeout(resolve, delayMs));
+    }
+  }
+  return null;
+}
+async function releaseDaemonLock(lockHandle) {
+  try {
+    await lockHandle.close();
+  } catch {
+  }
+  try {
+    if (existsSync(configuration.daemonLockFile)) {
+      unlinkSync(configuration.daemonLockFile);
+    }
+  } catch {
+  }
+}
+const SESSION_MAX_AGE_MS = 14 * 24 * 60 * 60 * 1e3;
+function readPersistedSessions() {
+  try {
+    if (!existsSync(configuration.sessionsFile)) return {};
+    const data = JSON.parse(readFileSync(configuration.sessionsFile, "utf-8"));
+    if (!data?.sessions || typeof data.sessions !== "object") return {};
+    const now = Date.now();
+    const sessions = {};
+    for (const [id, session] of Object.entries(data.sessions)) {
+      if (now - session.savedAt < SESSION_MAX_AGE_MS) {
+        sessions[id] = session;
+      }
+    }
+    return sessions;
+  } catch {
+    return {};
+  }
+}
+function readTrackedClaudeSessionIds() {
+  try {
+    if (!existsSync(configuration.sessionsFile)) return [];
+    const data = JSON.parse(readFileSync(configuration.sessionsFile, "utf-8"));
+    if (!data?.sessions || typeof data.sessions !== "object") return [];
+    const ids = /* @__PURE__ */ new Set();
+    for (const session of Object.values(data.sessions)) {
+      const metadata = (session ?? {}).metadata;
+      for (const id of [metadata?.claudeSessionId, metadata?.importedFromClaudeSessionId]) {
+        if (typeof id === "string" && id.length > 0) ids.add(id.toLowerCase());
+      }
+    }
+    return [...ids];
+  } catch {
+    return [];
+  }
+}
+function readTrackedCodexThreadIds() {
+  try {
+    if (!existsSync(configuration.sessionsFile)) return [];
+    const data = JSON.parse(readFileSync(configuration.sessionsFile, "utf-8"));
+    if (!data?.sessions || typeof data.sessions !== "object") return [];
+    const ids = /* @__PURE__ */ new Set();
+    for (const session of Object.values(data.sessions)) {
+      const metadata = (session ?? {}).metadata;
+      for (const id of [metadata?.codexThreadId, metadata?.importedFromCodexThreadId]) {
+        if (typeof id === "string" && id.length > 0) ids.add(id.toLowerCase());
+      }
+    }
+    return [...ids];
+  } catch {
+    return [];
+  }
+}
+function persistSession(sessionId, session) {
+  try {
+    const existing = readPersistedSessions();
+    existing[sessionId] = session;
+    const tmpFile = configuration.sessionsFile + ".tmp";
+    writePrivateFileSync(tmpFile, JSON.stringify({ sessions: existing }, null, 2));
+    renameSync(tmpFile, configuration.sessionsFile);
+    hardenPrivateFileSync(configuration.sessionsFile);
+  } catch (error) {
+    logger.debug(`[PERSISTENCE] Failed to persist session ${sessionId}:`, error);
+  }
+}
+function deletePersistedSessions(sessionIds) {
+  try {
+    const existing = readPersistedSessions();
+    let changed = false;
+    for (const id of sessionIds) {
+      if (id in existing) {
+        delete existing[id];
+        changed = true;
+      }
+    }
+    if (!changed) return;
+    const tmpFile = configuration.sessionsFile + ".tmp";
+    writePrivateFileSync(tmpFile, JSON.stringify({ sessions: existing }, null, 2));
+    renameSync(tmpFile, configuration.sessionsFile);
+    hardenPrivateFileSync(configuration.sessionsFile);
+  } catch (error) {
+    logger.debug(`[PERSISTENCE] Failed to delete persisted sessions:`, error);
+  }
+}
+
+export { SUPPORTED_SCHEMA_VERSION, SandboxConfigSchema, acquireDaemonLock, clearCredentials, clearDaemonState, clearMachineId, deletePersistedSessions, persistSession, readCredentials, readCredentialsForConfiguredRelay, readDaemonState, readPersistedSessions, readSettings, readSettingsOutcome, readTrackedClaudeSessionIds, readTrackedCodexThreadIds, releaseDaemonLock, updateSettings, writeCredentialsDataKey, writeCredentialsLegacy, writeDaemonState, writeSettings };

package/dist/piExtension.mjs

@@ -1,8 +1,9 @@
 import { Client } from '@modelcontextprotocol/sdk/client/index.js';
 import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
 import { resolve } from 'node:path';
-import { T as TERMINAL_TITLE_SUGGEST_METHOD, a as TerminalTitleSuggestResultSchema, p as projectPath } from './terminalTitleSuggest-DKgX3osW.mjs';
+import { p as projectPath } from './projectPath-BTBIMB57.mjs';
 import { r as resolveMcpTerminalId } from './terminalToolContext-CFeGeaNm.mjs';
+import { T as TERMINAL_TITLE_SUGGEST_METHOD, a as TerminalTitleSuggestResultSchema } from './terminalTitleSuggest-CeKsX_V6.mjs';
 import 'path';
 import 'url';
 import 'zod';

package/dist/piRunnerArgs-Bf7RUF__.cjs

@@ -0,0 +1,66 @@
+'use strict';
+
+var sessionModeFile = require('./sessionModeFile-BVCV5f7E.cjs');
+
+function detectDaemonSupervisor(env, platform = process.platform) {
+  const explicit = env.HAPPY_DAEMON_SUPERVISOR?.trim().toLowerCase();
+  if (explicit === "systemd") return "systemd";
+  if (explicit === "none") return "none";
+  if (platform === "linux" && typeof env.INVOCATION_ID === "string" && env.INVOCATION_ID.trim() !== "") return "systemd";
+  return "none";
+}
+const SYSTEMD_RESTART_HINT = "systemctl --user restart very-happy-daemon";
+
+function sanitizeSpawnModel(value) {
+  if (typeof value !== "string") return null;
+  return /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}(\[1m\])?$/i.test(value) ? value : null;
+}
+
+const IGNORED_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["--happy-starting-mode"]);
+const PI_ADAPTER_INSTALL_HINT = "very-happy pi needs the pi-acp adapter on PATH: npm install -g pi-acp@0.0.33";
+function piAdapterMissingHint(detail) {
+  return detail && /ENOENT/.test(detail) ? PI_ADAPTER_INSTALL_HINT : null;
+}
+function parsePiRunnerArgs(args) {
+  const parsed = { verbose: false, passthrough: [] };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      parsed.passthrough.push(...args.slice(i + 1));
+      break;
+    }
+    if (arg === "--started-by") {
+      const value = args[++i];
+      if (value === "daemon" || value === "terminal") parsed.startedBy = value;
+      continue;
+    }
+    if (arg === "--verbose") {
+      parsed.verbose = true;
+      continue;
+    }
+    if (arg === "--model") {
+      const model = sanitizeSpawnModel(args[++i]);
+      if (!model) throw new Error("Invalid --model identifier");
+      parsed.model = model;
+      continue;
+    }
+    if (arg === "--permission-mode") {
+      const mode = sessionModeFile.normalizeAcpPermissionMode(args[++i]);
+      if (mode) parsed.permissionMode = mode;
+      continue;
+    }
+    if (IGNORED_FLAGS_WITH_VALUE.has(arg)) {
+      i++;
+      continue;
+    }
+    throw new Error(`Unknown option for very-happy pi: ${arg} (use -- to pass args to pi-acp)`);
+  }
+  return parsed;
+}
+
+exports.PI_ADAPTER_INSTALL_HINT = PI_ADAPTER_INSTALL_HINT;
+exports.SYSTEMD_RESTART_HINT = SYSTEMD_RESTART_HINT;
+exports.detectDaemonSupervisor = detectDaemonSupervisor;
+exports.parsePiRunnerArgs = parsePiRunnerArgs;
+exports.piAdapterMissingHint = piAdapterMissingHint;
+exports.sanitizeSpawnModel = sanitizeSpawnModel;

package/dist/piRunnerArgs-Dk1ncwHF.mjs

@@ -0,0 +1,59 @@
+import { n as normalizeAcpPermissionMode } from './sessionModeFile-CDmDyRkD.mjs';
+
+function detectDaemonSupervisor(env, platform = process.platform) {
+  const explicit = env.HAPPY_DAEMON_SUPERVISOR?.trim().toLowerCase();
+  if (explicit === "systemd") return "systemd";
+  if (explicit === "none") return "none";
+  if (platform === "linux" && typeof env.INVOCATION_ID === "string" && env.INVOCATION_ID.trim() !== "") return "systemd";
+  return "none";
+}
+const SYSTEMD_RESTART_HINT = "systemctl --user restart very-happy-daemon";
+
+function sanitizeSpawnModel(value) {
+  if (typeof value !== "string") return null;
+  return /^[A-Za-z0-9][A-Za-z0-9._:/-]{0,255}(\[1m\])?$/i.test(value) ? value : null;
+}
+
+const IGNORED_FLAGS_WITH_VALUE = /* @__PURE__ */ new Set(["--happy-starting-mode"]);
+const PI_ADAPTER_INSTALL_HINT = "very-happy pi needs the pi-acp adapter on PATH: npm install -g pi-acp@0.0.33";
+function piAdapterMissingHint(detail) {
+  return detail && /ENOENT/.test(detail) ? PI_ADAPTER_INSTALL_HINT : null;
+}
+function parsePiRunnerArgs(args) {
+  const parsed = { verbose: false, passthrough: [] };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--") {
+      parsed.passthrough.push(...args.slice(i + 1));
+      break;
+    }
+    if (arg === "--started-by") {
+      const value = args[++i];
+      if (value === "daemon" || value === "terminal") parsed.startedBy = value;
+      continue;
+    }
+    if (arg === "--verbose") {
+      parsed.verbose = true;
+      continue;
+    }
+    if (arg === "--model") {
+      const model = sanitizeSpawnModel(args[++i]);
+      if (!model) throw new Error("Invalid --model identifier");
+      parsed.model = model;
+      continue;
+    }
+    if (arg === "--permission-mode") {
+      const mode = normalizeAcpPermissionMode(args[++i]);
+      if (mode) parsed.permissionMode = mode;
+      continue;
+    }
+    if (IGNORED_FLAGS_WITH_VALUE.has(arg)) {
+      i++;
+      continue;
+    }
+    throw new Error(`Unknown option for very-happy pi: ${arg} (use -- to pass args to pi-acp)`);
+  }
+  return parsed;
+}
+
+export { PI_ADAPTER_INSTALL_HINT as P, SYSTEMD_RESTART_HINT as S, piAdapterMissingHint as a, detectDaemonSupervisor as d, parsePiRunnerArgs as p, sanitizeSpawnModel as s };

package/dist/{piRuntime-NtF0YqjH.cjs → piRuntime-B_6TE9Eb.cjs}

@@ -3,8 +3,8 @@
 var promises = require('node:fs/promises');
 var node_crypto = require('node:crypto');
 var path = require('node:path');
-var persistence = require('./limits-BH5CV5vR.cjs');
-var index = require('./index-rH3DrQ5B.cjs');
+var configuration = require('./configuration-v9f8LM9T.cjs');
+var resources = require('./resources-JDPugcDq.cjs');
 
 async function publish(path, content, mode) {
   const temporary = `${path}.${node_crypto.randomUUID()}.new`;
@@ -12,10 +12,10 @@ async function publish(path, content, mode) {
   await promises.rename(temporary, path);
 }
 async function preparePiTeamsRuntime() {
-  const directory = path.join(persistence.configuration.happyHomeDir, "teams", "pi-runtime");
+  const directory = path.join(configuration.configuration.happyHomeDir, "teams", "pi-runtime");
   await promises.mkdir(directory, { recursive: true, mode: 448 });
   const extension = path.join(directory, "very-happy-teams.mjs");
-  await publish(extension, index.PI_TEAMS_EXTENSION, 384);
+  await publish(extension, resources.PI_TEAMS_EXTENSION, 384);
   const launcher = path.join(directory, "pi-teams.mjs");
   const script = `#!${process.execPath}
 import { spawn } from 'node:child_process';

package/dist/{piRuntime-kLZNpAAl.mjs → piRuntime-BwRdhK_N.mjs}

@@ -1,8 +1,8 @@
 import { mkdir, chmod, writeFile, rename } from 'node:fs/promises';
 import { randomUUID } from 'node:crypto';
 import { join } from 'node:path';
-import { c as configuration } from './limits-CjRj8IX5.mjs';
-import { P as PI_TEAMS_EXTENSION } from './index-BF6WfgV5.mjs';
+import { c as configuration } from './configuration-DoWFJUPm.mjs';
+import { P as PI_TEAMS_EXTENSION } from './resources-BdFBQi8r.mjs';
 
 async function publish(path, content, mode) {
   const temporary = `${path}.${randomUUID()}.new`;

package/dist/{piTerminal-B0fEOV_2.mjs → piTerminal-Bap3R8Re.mjs}

@@ -3,53 +3,50 @@ import { randomUUID } from 'node:crypto';
 import { createServer } from 'node:http';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { p as preparePiTeamsRuntime } from './piRuntime-kLZNpAAl.mjs';
-import { registerMcpTools, registerTerminalTitleSuggest } from './mcp-Dy3f_K0h.mjs';
-import './agentGuidance-KgvYuF3R.mjs';
+import { p as preparePiTeamsRuntime } from './piRuntime-BwRdhK_N.mjs';
+import { registerMcpTools, registerTerminalTitleSuggest } from './mcp-CeUd9KDr.mjs';
+import './agentGuidance-CQuNlNx8.mjs';
 import 'node:fs/promises';
 import 'node:os';
 import 'zod';
-import './limits-CjRj8IX5.mjs';
+import './logger-fXoNzNuB.mjs';
+import './persistence-oET5n61f.mjs';
+import './configuration-DoWFJUPm.mjs';
 import 'axios';
 import 'tweetnacl';
 import 'socket.io-client';
-import './types-Dh-s4Lqs.mjs';
+import './terminals-Dlg0x3nY.mjs';
 import 'node:fs';
 import 'node:path';
 import { r as resolveMcpTerminalId } from './terminalToolContext-CFeGeaNm.mjs';
-import './index-BF6WfgV5.mjs';
-import 'chalk';
-import 'cross-spawn';
-import 'node:readline';
-import './terminalTitleSuggest-DKgX3osW.mjs';
+import './resources-BdFBQi8r.mjs';
+import './tools-BmQQUATY.mjs';
+import './client-Brn-UwVk.mjs';
+import './context-C9GHPLEm.mjs';
+import '@modelcontextprotocol/sdk/server/stdio.js';
+import './controlClient-DjoKTtgK.mjs';
+import './limits-DIo7rEBR.mjs';
+import './assistantTools-CgiTbnWb.mjs';
+import './sessionOps-C_f1wKOr.mjs';
+import './authRelay-DSAvg1uv.mjs';
+import './time-BZNdNiIV.mjs';
+import './backgroundTaskActivity-8PdPxrvy.mjs';
+import './remoteSessionClient-CO7qOjR0.mjs';
+import './ids-DU6sLx4C.mjs';
+import './bootstrap-BNQq05jR.mjs';
+import './previewPath-CXN4Vag0.mjs';
+import './terminalTitleSuggest-CeKsX_V6.mjs';
+import './titleGenerator-ox6ptCsp.mjs';
+import 'node:module';
+import './oneShotPrompts-DT4p6RNd.mjs';
+import './projectPath-BTBIMB57.mjs';
 import 'path';
 import 'url';
-import 'fs/promises';
-import 'ink';
-import 'react';
-import '@anthropic-ai/claude-agent-sdk';
-import 'node:events';
-import 'os';
-import 'child_process';
-import '@paralleldrive/cuid2';
-import 'fs';
-import '@anthropic-ai/sandbox-runtime';
-import 'expo-server-sdk';
-import 'crypto';
-import 'ps-list';
-import 'tmp';
-import 'open';
-import 'fastify';
-import 'fastify-type-provider-zod';
-import 'node:module';
+import './trimIdent-BAjmv_TG.mjs';
+import 'chalk';
 import 'node:util';
-import 'http';
-import 'util';
-import 'inquirer';
-import 'node:url';
-import 'node:readline/promises';
-import '@modelcontextprotocol/sdk/server/stdio.js';
-import 'node-pty';
+import './package-uOg9SCKi.mjs';
+import './tmuxSocket-B8Yx20sT.mjs';
 
 async function startPiTerminalTools(terminalId) {
   const path = `/terminal-tools/${randomUUID()}`;