contextswitch 0.1.5 → 0.1.7

package/dist/archive-HW56NYMR.js

@@ -0,0 +1,10 @@
+import {
+  archiveCommand,
+  listArchives
+} from "./chunk-GDWJEQJQ.js";
+import "./chunk-72MK25T3.js";
+import "./chunk-F36TGFK2.js";
+export {
+  archiveCommand,
+  listArchives
+};

package/dist/{chunk-YMFZWGZO.js → chunk-72MK25T3.js}

@@ -1,10 +1,7 @@
 import {
+  debug,
   paths
-} from "./chunk-A7YXSI66.js";
-
-// src/core/config.ts
-import { readFileSync, existsSync, writeFileSync, readdirSync, renameSync, unlinkSync } from "fs";
-import { parse, stringify } from "yaml";
+} from "./chunk-F36TGFK2.js";
 
 // src/core/domain.ts
 import { z } from "zod";
@@ -13,15 +10,37 @@ var MCPServerSchema = z.object({
   args: z.array(z.string()).optional().describe("Arguments for the command"),
   env: z.record(z.string()).optional().describe("Environment variables")
 });
+var DOMAIN_NAME_REGEX = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/;
+var ENV_VAR_NAME_REGEX = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+var LAUNCH_MODES = ["window", "tab", "inline"];
+function validateDomainName(name) {
+  if (!name || name.length === 0) {
+    return "Domain name cannot be empty";
+  }
+  if (name.length > 64) {
+    return "Domain name must be 64 characters or fewer";
+  }
+  if (!DOMAIN_NAME_REGEX.test(name)) {
+    return "Domain name must start with a letter or number and contain only letters, numbers, hyphens, underscores, and dots";
+  }
+  if (name === "." || name === "..") {
+    return 'Domain name cannot be "." or ".."';
+  }
+  return null;
+}
 var DomainConfigSchema = z.object({
-  name: z.string().min(1).describe("Domain identifier"),
+  name: z.string().min(1).regex(DOMAIN_NAME_REGEX, "Domain name must start with a letter or number and contain only letters, numbers, hyphens, underscores, and dots").describe("Domain identifier"),
   workingDirectory: z.string().describe("Working directory for this domain"),
   claudeConfig: z.object({
     instructions: z.string().optional().describe("Path to CLAUDE.md file"),
     memory: z.array(z.string()).optional().describe("Memory file paths")
   }).optional(),
   mcpServers: z.record(MCPServerSchema).optional().describe("MCP server configurations"),
-  env: z.record(z.string()).optional().describe("Environment variables for this domain"),
+  env: z.record(
+    z.string().regex(ENV_VAR_NAME_REGEX, "Environment variable names must start with a letter or underscore and contain only letters, digits, and underscores"),
+    z.string()
+  ).optional().describe("Environment variables for this domain"),
+  launchMode: z.enum(LAUNCH_MODES).optional().describe("How to open Claude: window, tab, or inline"),
   extends: z.string().optional().describe("Parent domain to inherit from"),
   metadata: z.object({
     description: z.string().optional(),
@@ -49,6 +68,7 @@ var GlobalConfigSchema = z.object({
   autoArchive: z.boolean().default(true),
   archiveDirectory: z.string().optional(),
   claudePath: z.string().optional().describe("Path to Claude CLI executable"),
+  defaultLaunchMode: z.enum(LAUNCH_MODES).optional().describe("Default launch mode: window, tab, or inline"),
   logLevel: z.enum(["debug", "info", "warn", "error"]).default("info"),
   platform: z.object({
     forceType: z.enum(["darwin", "linux", "win32"]).optional(),
@@ -56,6 +76,10 @@ var GlobalConfigSchema = z.object({
     killTimeout: z.number().default(5e3).describe("Milliseconds to wait before force kill")
   }).optional()
 });
+var SessionFallbackMarkerSchema = z.object({
+  domain: z.string().min(1).regex(DOMAIN_NAME_REGEX),
+  sessionId: z.string().min(1)
+});
 var DEFAULT_DOMAIN_TEMPLATE = {
   name: "default",
   workingDirectory: process.cwd(),
@@ -70,6 +94,15 @@ var DEFAULT_DOMAIN_TEMPLATE = {
     tags: []
   }
 };
+function validateEnvVarName(name) {
+  if (!name || name.length === 0) {
+    return "Environment variable name cannot be empty";
+  }
+  if (!ENV_VAR_NAME_REGEX.test(name)) {
+    return `Invalid environment variable name '${name}': must start with a letter or underscore and contain only letters, digits, and underscores`;
+  }
+  return null;
+}
 function validateDomain(data) {
   return DomainConfigSchema.parse(data);
 }
@@ -86,30 +119,28 @@ function createInitialState() {
 }
 
 // src/core/config.ts
+import { readFileSync, existsSync, writeFileSync, readdirSync, renameSync, unlinkSync } from "fs";
+import { parse, stringify } from "yaml";
 var ConfigManager = class {
-  globalConfig = null;
-  state = null;
-  domainCache = /* @__PURE__ */ new Map();
   /**
    * Load global configuration
    */
   loadGlobalConfig() {
     const configPath = paths.globalConfigFile;
     if (!existsSync(configPath)) {
-      this.globalConfig = {
+      const defaultConfig = {
         version: "1.0.0",
         defaultDomain: "default",
         autoArchive: true,
         logLevel: "info"
       };
-      this.saveGlobalConfig(this.globalConfig);
-      return this.globalConfig;
+      this.saveGlobalConfig(defaultConfig);
+      return defaultConfig;
     }
     try {
       const content = readFileSync(configPath, "utf-8");
       const data = parse(content);
-      this.globalConfig = GlobalConfigSchema.parse(data);
-      return this.globalConfig;
+      return GlobalConfigSchema.parse(data);
     } catch (error) {
       throw new Error(`Failed to load global config: ${error}`);
     }
@@ -123,23 +154,25 @@ var ConfigManager = class {
     const content = stringify(config, { indent: 2 });
     writeFileSync(tempPath, content, "utf-8");
     renameSync(tempPath, configPath);
-    this.globalConfig = config;
   }
   /**
    * Load state file
    */
   loadState() {
     const statePath = paths.stateFile;
+    debug("config", `Loading state from ${statePath}`);
     if (!existsSync(statePath)) {
-      this.state = createInitialState();
-      this.saveState(this.state);
-      return this.state;
+      debug("config", "No state file found, creating initial state");
+      const initial = createInitialState();
+      this.saveState(initial);
+      return initial;
     }
     try {
       const content = readFileSync(statePath, "utf-8");
       const data = JSON.parse(content);
-      this.state = validateState(data);
-      return this.state;
+      const state = validateState(data);
+      debug("config", `State loaded: activeDomain=${state.activeDomain}, sessions=${Object.keys(state.sessions || {}).join(",") || "none"}`);
+      return state;
     } catch (error) {
       throw new Error(`Failed to load state: ${error}`);
     }
@@ -150,19 +183,23 @@ var ConfigManager = class {
   saveState(state) {
     const statePath = paths.stateFile;
     const tempPath = `${statePath}.tmp`;
+    debug("config", `Saving state to ${statePath} (activeDomain=${state.activeDomain})`);
     const content = JSON.stringify(state, null, 2);
     writeFileSync(tempPath, content, "utf-8");
     renameSync(tempPath, statePath);
-    this.state = state;
   }
   /**
    * Load a domain configuration
    */
   loadDomain(domainName) {
-    if (this.domainCache.has(domainName)) {
-      return this.domainCache.get(domainName);
-    }
+    return this.loadDomainInternal(domainName, []);
+  }
+  /**
+   * Internal domain loader with cycle detection for inheritance chains.
+   */
+  loadDomainInternal(domainName, ancestors) {
     const domainPath = paths.domainConfigFile(domainName);
+    debug("config", `Loading domain '${domainName}' from ${domainPath}`);
     if (!existsSync(domainPath)) {
       throw new Error(`Domain '${domainName}' not found`);
     }
@@ -171,7 +208,11 @@ var ConfigManager = class {
       const data = parse(content);
       let domain = validateDomain(data);
       if (domain.extends) {
-        const parent = this.loadDomain(domain.extends);
+        if (ancestors.includes(domain.extends)) {
+          throw new Error(`Circular inheritance detected: ${[...ancestors, domainName, domain.extends].join(" -> ")}`);
+        }
+        debug("config", `Domain '${domainName}' extends '${domain.extends}', merging`);
+        const parent = this.loadDomainInternal(domain.extends, [...ancestors, domainName]);
         domain = this.mergeDomains(parent, domain);
       }
       domain.workingDirectory = paths.expandPath(domain.workingDirectory);
@@ -181,7 +222,6 @@ var ConfigManager = class {
       if (domain.claudeConfig?.memory) {
         domain.claudeConfig.memory = domain.claudeConfig.memory.map((p) => paths.expandPath(p));
       }
-      this.domainCache.set(domainName, domain);
       return domain;
     } catch (error) {
       throw new Error(`Failed to load domain '${domainName}': ${error}`);
@@ -196,7 +236,6 @@ var ConfigManager = class {
     const content = stringify(domain, { indent: 2 });
     writeFileSync(tempPath, content, "utf-8");
     renameSync(tempPath, domainPath);
-    this.domainCache.set(domain.name, domain);
   }
   /**
    * Create a new domain from template
@@ -241,7 +280,6 @@ var ConfigManager = class {
       throw new Error(`Domain '${domainName}' not found`);
     }
     unlinkSync(domainPath);
-    this.domainCache.delete(domainName);
   }
   /**
    * Merge two domain configurations (child overrides parent)
@@ -289,13 +327,14 @@ var ConfigManager = class {
    * Clear cache
    */
   clearCache() {
-    this.globalConfig = null;
-    this.state = null;
-    this.domainCache.clear();
   }
 };
 var configManager = new ConfigManager();
 
 export {
+  LAUNCH_MODES,
+  validateDomainName,
+  SessionFallbackMarkerSchema,
+  validateEnvVarName,
   configManager
 };

package/dist/{chunk-A7YXSI66.js → chunk-F36TGFK2.js}

@@ -72,6 +72,9 @@ var Paths = class _Paths {
    * Get domain config file path
    */
   domainConfigFile(domainName) {
+    if (domainName.includes("/") || domainName.includes("\\") || domainName === ".." || domainName === ".") {
+      throw new Error(`Unsafe domain name: ${domainName}`);
+    }
     return join(this.domainsDir, `${domainName}.yml`);
   }
   /**
@@ -108,7 +111,9 @@ var Paths = class _Paths {
    * Expand environment variables and ~ in paths
    */
   expandPath(inputPath) {
-    if (inputPath.startsWith("~/")) {
+    if (inputPath === "~") {
+      inputPath = homedir();
+    } else if (inputPath.startsWith("~/")) {
       inputPath = join(homedir(), inputPath.slice(2));
     }
     inputPath = inputPath.replace(/\$([A-Z_][A-Z0-9_]*)/gi, (match, varName) => {
@@ -158,6 +163,20 @@ var Paths = class _Paths {
 };
 var paths = Paths.instance;
 
+// src/core/debug.ts
+import picocolors from "picocolors";
+var pc = picocolors;
+var enabled = false;
+function enableDebug() {
+  enabled = true;
+}
+function debug(context, message) {
+  if (!enabled) return;
+  console.log(pc.dim(`[debug:${context}] ${message}`));
+}
+
 export {
-  paths
+  paths,
+  enableDebug,
+  debug
 };