@panorama-ai/gateway 2.24.102 → 2.24.108

package/dist/index.js

@@ -54,18 +54,8 @@ const CLAUDE_ENV_ALLOWLIST = [
     'SSH_AUTH_SOCK',
     'SSH_AGENT_PID',
 ];
-const CONFIG_DIR = process.env.PANORAMA_GATEWAY_CONFIG_DIR || path.join(os.homedir(), '.panorama');
-const SUBAGENT_WORKDIR_ROOT = path.join(CONFIG_DIR, 'subagents');
-const CLAUDE_GATEWAY_HOME = process.env.PANORAMA_CLAUDE_HOME || null;
-const CONFIG_PATH = process.env.PANORAMA_GATEWAY_CONFIG_PATH || path.join(CONFIG_DIR, 'gateway.json');
-const LOG_PATH = process.env.PANORAMA_GATEWAY_LOG_PATH || path.join(path.dirname(CONFIG_PATH), 'gateway.log');
-const PID_PATH = process.env.PANORAMA_GATEWAY_PID_PATH || path.join(path.dirname(CONFIG_PATH), 'gateway.pid');
+const DEFAULT_CONFIG_DIR = path.join(os.homedir(), '.panorama');
 const DEFAULT_CLAUDE_PATH = path.join(os.homedir(), '.claude', 'local', 'claude');
-const CLAUDE_COMMAND = process.env.PANORAMA_CLAUDE_CLI ||
-    process.env.CLAUDE_CLI ||
-    (fsSync.existsSync(DEFAULT_CLAUDE_PATH) ? DEFAULT_CLAUDE_PATH : 'claude');
-const CODEX_COMMAND = process.env.PANORAMA_CODEX_CLI || process.env.CODEX_CLI || 'codex';
-const GEMINI_COMMAND = process.env.PANORAMA_GEMINI_CLI || process.env.GEMINI_CLI || 'gemini';
 let CLAUDE_SUPPORT = null;
 let PROVIDER_CAPABILITIES = null;
 const GATEWAY_CONCURRENCY = (() => {
@@ -80,6 +70,7 @@ const GATEWAY_CONCURRENCY = (() => {
 const activeSubagentRuns = new Map();
 const pendingCancelByRunId = new Map();
 const pendingCancelBySubagentId = new Map();
+let ACTIVE_OPTIONS = null;
 function parseArgs(argv) {
     const positional = [];
     const options = {};
@@ -113,7 +104,7 @@ function parseArgs(argv) {
     return { command, positional, options };
 }
 function printHelp() {
-    console.log(`\nPanorama Gateway\n\nUsage:\n  panorama-gateway pair <PAIRING_CODE> [--device-name \"My Mac\"] [--supabase-url URL] [--anon-key KEY]\n  panorama-gateway start [--device-name \"My Mac\"] [--daemon]\n  panorama-gateway stop\n  panorama-gateway logs [--lines 200] [--no-follow]\n\nEnvironment options:\n  --env <local|dev|test|stage|prod>  Load .env.<env> from repo root (defaults to .env)\n  --env-file <path>                 Load a specific env file\n  PANORAMA_ENV                      Same as --env\n  PANORAMA_ENV_FILE                 Same as --env-file\n\nEnvironment overrides:\n  PANORAMA_SUPABASE_URL or SUPABASE_URL\n  PANORAMA_SUPABASE_ANON_KEY or SUPABASE_ANON_KEY or SUPABASE_PUBLISHABLE_KEY\n  PANORAMA_GATEWAY_CONFIG_PATH to override config path\n  PANORAMA_GATEWAY_LOG_PATH to override log path\n  PANORAMA_GATEWAY_PID_PATH to override pid path\n  PANORAMA_CLAUDE_CLI or CLAUDE_CLI to override claude command\n`);
+    console.log(`\nPanorama Gateway\n\nUsage:\n  panorama-gateway pair <PAIRING_CODE> [--device-name \"My Mac\"] [--supabase-url URL] [--anon-key KEY]\n  panorama-gateway start [--device-name \"My Mac\"] [--foreground|--daemon]\n  panorama-gateway stop\n  panorama-gateway status\n  panorama-gateway logs [--lines 200] [--no-follow]\n\nNotes:\n  Start runs in the background by default for the built CLI. Use --foreground to keep it attached.\n\nEnvironment options:\n  --env <local|dev|test|stage|prod>  Load .env.<env> from repo root (defaults to .env)\n  --env-file <path>                 Load a specific env file\n  PANORAMA_ENV                      Same as --env\n  PANORAMA_ENV_FILE                 Same as --env-file\n\nCLI overrides:\n  --config-dir <path>               Override config directory (default: ~/.panorama)\n  --config-path <path>              Override gateway config file\n  --log-path <path>                 Override gateway log file\n  --pid-path <path>                 Override gateway pid file\n  --claude-cli <path>               Override Claude CLI command\n  --codex-cli <path>                Override Codex CLI command\n  --gemini-cli <path>               Override Gemini CLI command\n  --claude-home <path>              Override Claude home directory\n\nEnvironment overrides:\n  PANORAMA_SUPABASE_URL or SUPABASE_URL\n  PANORAMA_SUPABASE_ANON_KEY or SUPABASE_ANON_KEY or SUPABASE_PUBLISHABLE_KEY\n  PANORAMA_GATEWAY_CONFIG_DIR\n  PANORAMA_GATEWAY_CONFIG_PATH\n  PANORAMA_GATEWAY_LOG_PATH\n  PANORAMA_GATEWAY_PID_PATH\n  PANORAMA_CLAUDE_CLI or CLAUDE_CLI\n  PANORAMA_CODEX_CLI or CODEX_CLI\n  PANORAMA_GEMINI_CLI or GEMINI_CLI\n  PANORAMA_CLAUDE_HOME\n`);
 }
 function getStringOption(options, key) {
     const value = options[key];
@@ -121,6 +112,87 @@ function getStringOption(options, key) {
         return value;
     return undefined;
 }
+function getActiveOptions(options) {
+    return options ?? ACTIVE_OPTIONS ?? {};
+}
+function resolveGatewayPaths(options) {
+    const resolvedOptions = getActiveOptions(options);
+    const configDirRaw = getStringOption(resolvedOptions, 'config-dir') || process.env.PANORAMA_GATEWAY_CONFIG_DIR;
+    const configDir = configDirRaw ? path.resolve(configDirRaw) : DEFAULT_CONFIG_DIR;
+    const configPathRaw = getStringOption(resolvedOptions, 'config-path') || process.env.PANORAMA_GATEWAY_CONFIG_PATH;
+    const configPath = configPathRaw ? path.resolve(configPathRaw) : path.join(configDir, 'gateway.json');
+    const logPathRaw = getStringOption(resolvedOptions, 'log-path') || process.env.PANORAMA_GATEWAY_LOG_PATH;
+    const logPath = logPathRaw ? path.resolve(logPathRaw) : path.join(path.dirname(configPath), 'gateway.log');
+    const pidPathRaw = getStringOption(resolvedOptions, 'pid-path') || process.env.PANORAMA_GATEWAY_PID_PATH;
+    const pidPath = pidPathRaw ? path.resolve(pidPathRaw) : path.join(path.dirname(configPath), 'gateway.pid');
+    return { configDir, configPath, logPath, pidPath };
+}
+function resolveSubagentWorkdirRoot(options) {
+    return path.join(resolveGatewayPaths(options).configDir, 'subagents');
+}
+function resolveClaudeGatewayHome(options) {
+    const resolvedOptions = getActiveOptions(options);
+    const raw = getStringOption(resolvedOptions, 'claude-home') || process.env.PANORAMA_CLAUDE_HOME || null;
+    return raw ? path.resolve(raw) : null;
+}
+function resolveClaudeCommand(options) {
+    const resolvedOptions = getActiveOptions(options);
+    const override = getStringOption(resolvedOptions, 'claude-cli') ||
+        process.env.PANORAMA_CLAUDE_CLI ||
+        process.env.CLAUDE_CLI;
+    if (override)
+        return override;
+    return fsSync.existsSync(DEFAULT_CLAUDE_PATH) ? DEFAULT_CLAUDE_PATH : 'claude';
+}
+function resolveCodexCommand(options) {
+    const resolvedOptions = getActiveOptions(options);
+    return (getStringOption(resolvedOptions, 'codex-cli') ||
+        process.env.PANORAMA_CODEX_CLI ||
+        process.env.CODEX_CLI ||
+        'codex');
+}
+function resolveGeminiCommand(options) {
+    const resolvedOptions = getActiveOptions(options);
+    return (getStringOption(resolvedOptions, 'gemini-cli') ||
+        process.env.PANORAMA_GEMINI_CLI ||
+        process.env.GEMINI_CLI ||
+        'gemini');
+}
+function buildGatewayEnvOverrides(options) {
+    const resolvedOptions = getActiveOptions(options);
+    const env = {};
+    const configDir = getStringOption(resolvedOptions, 'config-dir');
+    const configPath = getStringOption(resolvedOptions, 'config-path');
+    const logPath = getStringOption(resolvedOptions, 'log-path');
+    const pidPath = getStringOption(resolvedOptions, 'pid-path');
+    const claudeCli = getStringOption(resolvedOptions, 'claude-cli');
+    const codexCli = getStringOption(resolvedOptions, 'codex-cli');
+    const geminiCli = getStringOption(resolvedOptions, 'gemini-cli');
+    const claudeHome = getStringOption(resolvedOptions, 'claude-home');
+    const supabaseUrl = getStringOption(resolvedOptions, 'supabase-url');
+    const supabaseAnonKey = getStringOption(resolvedOptions, 'anon-key');
+    if (configDir)
+        env.PANORAMA_GATEWAY_CONFIG_DIR = configDir;
+    if (configPath)
+        env.PANORAMA_GATEWAY_CONFIG_PATH = configPath;
+    if (logPath)
+        env.PANORAMA_GATEWAY_LOG_PATH = logPath;
+    if (pidPath)
+        env.PANORAMA_GATEWAY_PID_PATH = pidPath;
+    if (claudeCli)
+        env.PANORAMA_CLAUDE_CLI = claudeCli;
+    if (codexCli)
+        env.PANORAMA_CODEX_CLI = codexCli;
+    if (geminiCli)
+        env.PANORAMA_GEMINI_CLI = geminiCli;
+    if (claudeHome)
+        env.PANORAMA_CLAUDE_HOME = claudeHome;
+    if (supabaseUrl)
+        env.PANORAMA_SUPABASE_URL = supabaseUrl;
+    if (supabaseAnonKey)
+        env.PANORAMA_SUPABASE_ANON_KEY = supabaseAnonKey;
+    return env;
+}
 function normalizeEnvName(raw) {
     if (!raw)
         return null;
@@ -179,13 +251,15 @@ function resolveSupabaseAnonKey(options, config) {
         config?.supabaseAnonKey ||
         '');
 }
-async function loadConfig() {
-    const raw = await fs.readFile(CONFIG_PATH, 'utf-8');
+async function loadConfig(options) {
+    const { configPath } = resolveGatewayPaths(options);
+    const raw = await fs.readFile(configPath, 'utf-8');
     return JSON.parse(raw);
 }
-async function saveConfig(config) {
-    await fs.mkdir(path.dirname(CONFIG_PATH), { recursive: true });
-    await fs.writeFile(CONFIG_PATH, JSON.stringify(config, null, 2));
+async function saveConfig(config, options) {
+    const { configPath } = resolveGatewayPaths(options);
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, JSON.stringify(config, null, 2));
 }
 function logInfo(message, data) {
     if (data) {
@@ -203,9 +277,10 @@ function logError(message, data) {
         console.error(`[gateway] ${message}`);
     }
 }
-function readPidFile() {
+function readPidFile(options) {
+    const { pidPath } = resolveGatewayPaths(options);
     try {
-        const raw = fsSync.readFileSync(PID_PATH, 'utf-8').trim();
+        const raw = fsSync.readFileSync(pidPath, 'utf-8').trim();
         const pid = Number.parseInt(raw, 10);
         return Number.isFinite(pid) ? pid : null;
     }
@@ -213,13 +288,15 @@ function readPidFile() {
         return null;
     }
 }
-async function writePidFile(pid) {
-    await fs.mkdir(path.dirname(PID_PATH), { recursive: true });
-    await fs.writeFile(PID_PATH, `${pid}\n`);
+async function writePidFile(pid, options) {
+    const { pidPath } = resolveGatewayPaths(options);
+    await fs.mkdir(path.dirname(pidPath), { recursive: true });
+    await fs.writeFile(pidPath, `${pid}\n`);
 }
-async function removePidFile() {
+async function removePidFile(options) {
+    const { pidPath } = resolveGatewayPaths(options);
     try {
-        await fs.unlink(PID_PATH);
+        await fs.unlink(pidPath);
     }
     catch {
         // ignore missing pid
@@ -279,17 +356,19 @@ async function pairGateway(code, options) {
         teamId: body.team_id,
         deviceName,
     };
-    await saveConfig(config);
+    await saveConfig(config, options);
+    const { configPath } = resolveGatewayPaths(options);
     logInfo('Gateway paired successfully', {
         gatewayId: body.gateway_id,
         teamId: body.team_id,
-        configPath: CONFIG_PATH,
+        configPath,
     });
 }
 async function execClaudeVersion() {
     const start = Date.now();
+    const command = resolveClaudeCommand();
     try {
-        const { stdout, stderr } = await execFileAsync(CLAUDE_COMMAND, ['--version'], {
+        const { stdout, stderr } = await execFileAsync(command, ['--version'], {
             timeout: DEFAULT_CLAUDE_TIMEOUT_MS,
         });
         const durationMs = Date.now() - start;
@@ -318,8 +397,9 @@ async function execClaudeVersion() {
 }
 async function execClaudeHelp() {
     const start = Date.now();
+    const command = resolveClaudeCommand();
     try {
-        const { stdout, stderr } = await execFileAsync(CLAUDE_COMMAND, ['--help'], {
+        const { stdout, stderr } = await execFileAsync(command, ['--help'], {
             timeout: DEFAULT_CLAUDE_TIMEOUT_MS,
         });
         const durationMs = Date.now() - start;
@@ -378,12 +458,13 @@ async function buildCapabilities() {
     if (claudeCapabilities?.supported_flags) {
         CLAUDE_SUPPORT = coerceClaudeSupport(claudeCapabilities.supported_flags);
     }
+    const resolvedClaudeCommand = resolveClaudeCommand();
     const claudeCliLegacy = claudeCapabilities
         ? {
             available: claudeCapabilities.available,
             version: claudeCapabilities.version,
             error: claudeCapabilities.error,
-            command: `${CLAUDE_COMMAND} --version`,
+            command: `${resolvedClaudeCommand} --version`,
             supported_flags: claudeCapabilities.supported_flags,
         }
         : {
@@ -408,14 +489,15 @@ function appendClaudeIsolationArgs(args, support) {
     }
 }
 async function ensureClaudeGatewayHome() {
-    if (!CLAUDE_GATEWAY_HOME)
+    const claudeHome = resolveClaudeGatewayHome();
+    if (!claudeHome)
         return;
-    await fs.mkdir(CLAUDE_GATEWAY_HOME, { recursive: true });
-    await fs.mkdir(path.join(CLAUDE_GATEWAY_HOME, 'xdg', 'config'), { recursive: true });
-    await fs.mkdir(path.join(CLAUDE_GATEWAY_HOME, 'xdg', 'cache'), { recursive: true });
-    await fs.mkdir(path.join(CLAUDE_GATEWAY_HOME, 'xdg', 'data'), { recursive: true });
+    await fs.mkdir(claudeHome, { recursive: true });
+    await fs.mkdir(path.join(claudeHome, 'xdg', 'config'), { recursive: true });
+    await fs.mkdir(path.join(claudeHome, 'xdg', 'cache'), { recursive: true });
+    await fs.mkdir(path.join(claudeHome, 'xdg', 'data'), { recursive: true });
     const sourceSessionEnv = path.join(os.homedir(), '.claude', 'session-env');
-    const destSessionEnv = path.join(CLAUDE_GATEWAY_HOME, 'session-env');
+    const destSessionEnv = path.join(claudeHome, 'session-env');
     try {
         const srcStat = await fs.stat(sourceSessionEnv);
         if (srcStat.isDirectory()) {
@@ -439,11 +521,12 @@ function buildClaudeEnv() {
             env[key] = value;
         }
     }
-    if (CLAUDE_GATEWAY_HOME) {
-        env.HOME = CLAUDE_GATEWAY_HOME;
-        env.XDG_CONFIG_HOME = path.join(CLAUDE_GATEWAY_HOME, 'xdg', 'config');
-        env.XDG_CACHE_HOME = path.join(CLAUDE_GATEWAY_HOME, 'xdg', 'cache');
-        env.XDG_DATA_HOME = path.join(CLAUDE_GATEWAY_HOME, 'xdg', 'data');
+    const claudeHome = resolveClaudeGatewayHome();
+    if (claudeHome) {
+        env.HOME = claudeHome;
+        env.XDG_CONFIG_HOME = path.join(claudeHome, 'xdg', 'config');
+        env.XDG_CACHE_HOME = path.join(claudeHome, 'xdg', 'cache');
+        env.XDG_DATA_HOME = path.join(claudeHome, 'xdg', 'data');
     }
     return env;
 }
@@ -672,7 +755,7 @@ function isUuid(value) {
     return /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value);
 }
 async function ensureSubagentWorkDir(subagentId) {
-    const dir = path.join(SUBAGENT_WORKDIR_ROOT, subagentId);
+    const dir = path.join(resolveSubagentWorkdirRoot(), subagentId);
     await fs.mkdir(dir, { recursive: true });
     return dir;
 }
@@ -1022,11 +1105,12 @@ async function updateJobDebug(supabase, jobId, debug) {
 }
 async function handleDiagnosticJob() {
     const output = await execClaudeVersion();
+    const command = resolveClaudeCommand();
     if (!output.ok) {
         return {
             ok: false,
             result: {
-                command: `${CLAUDE_COMMAND} --version`,
+                command: `${command} --version`,
                 stdout: output.stdout,
                 stderr: output.stderr,
                 exit_code: output.exitCode,
@@ -1039,7 +1123,7 @@ async function handleDiagnosticJob() {
     return {
         ok: true,
         result: {
-            command: `${CLAUDE_COMMAND} --version`,
+            command: `${command} --version`,
             stdout: output.stdout,
             stderr: output.stderr,
             exit_code: output.exitCode,
@@ -1352,10 +1436,10 @@ async function handleSubagentRunJob(supabase, job) {
                 ? toFlagRecord(CLAUDE_SUPPORT ?? DEFAULT_CLAUDE_SUPPORT)
                 : {});
         const command = adapterId === 'codex'
-            ? CODEX_COMMAND
+            ? resolveCodexCommand()
             : adapterId === 'gemini'
-                ? GEMINI_COMMAND
-                : CLAUDE_COMMAND;
+                ? resolveGeminiCommand()
+                : resolveClaudeCommand();
         runPlan = adapter.buildRunPlan({
             prompt,
             config: configPayload,
@@ -1929,49 +2013,61 @@ async function processJob(supabase, config, job) {
     }, `Unsupported job type: ${claimed.job_type}`);
 }
 async function startGateway(options) {
-    const daemonRequested = options.daemon === true || options.background === true;
+    const paths = resolveGatewayPaths(options);
     const foregroundRequested = options.foreground === true;
+    const explicitDaemon = options.daemon === true || options.background === true;
+    let daemonRequested = explicitDaemon || !foregroundRequested;
     if (daemonRequested && !foregroundRequested) {
-        const existingPid = readPidFile();
+        const existingPid = readPidFile(options);
         if (existingPid && isProcessAlive(existingPid)) {
             logInfo('Gateway already running', { pid: existingPid });
             return;
         }
         const entryPath = process.argv[1] || '';
         if (entryPath.endsWith('.ts')) {
-            throw new Error('Daemon mode requires the built gateway. Run "pnpm gateway:start -- --daemon".');
+            if (!explicitDaemon) {
+                logInfo('Gateway running in foreground (dev mode detected)');
+                daemonRequested = false;
+            }
+            else {
+                throw new Error('Daemon mode requires the built gateway. Run "pnpm gateway:start -- --daemon".');
+            }
         }
-        await fs.mkdir(path.dirname(LOG_PATH), { recursive: true });
-        const logHandle = await fs.open(LOG_PATH, 'a');
-        const childArgs = [entryPath, 'start', '--foreground'];
-        const deviceName = getStringOption(options, 'device-name') || process.env.PANORAMA_GATEWAY_DEVICE_NAME;
-        if (deviceName) {
-            childArgs.push('--device-name', deviceName);
+        if (!daemonRequested) {
+            // fall through to foreground startup
         }
-        const child = spawn(process.execPath, childArgs, {
-            detached: true,
-            stdio: ['ignore', logHandle.fd, logHandle.fd],
-            env: {
-                ...process.env,
-                PANORAMA_GATEWAY_LOG_PATH: LOG_PATH,
-                PANORAMA_GATEWAY_PID_PATH: PID_PATH,
-            },
-        });
-        child.unref();
-        await logHandle.close();
-        if (!child.pid) {
-            throw new Error('Failed to determine gateway process id');
+        else {
+            await fs.mkdir(path.dirname(paths.logPath), { recursive: true });
+            const logHandle = await fs.open(paths.logPath, 'a');
+            const childArgs = [entryPath, 'start', '--foreground'];
+            const deviceName = getStringOption(options, 'device-name') || process.env.PANORAMA_GATEWAY_DEVICE_NAME;
+            if (deviceName) {
+                childArgs.push('--device-name', deviceName);
+            }
+            const child = spawn(process.execPath, childArgs, {
+                detached: true,
+                stdio: ['ignore', logHandle.fd, logHandle.fd],
+                env: {
+                    ...process.env,
+                    ...buildGatewayEnvOverrides(options),
+                },
+            });
+            child.unref();
+            await logHandle.close();
+            if (!child.pid) {
+                throw new Error('Failed to determine gateway process id');
+            }
+            await writePidFile(child.pid, options);
+            logInfo('Gateway started in background', { pid: child.pid, logPath: paths.logPath });
+            return;
         }
-        await writePidFile(child.pid);
-        logInfo('Gateway started in background', { pid: child.pid, logPath: LOG_PATH });
-        return;
     }
     let config;
     try {
-        config = await loadConfig();
+        config = await loadConfig(options);
     }
     catch (error) {
-        throw new Error(`Gateway config not found. Run "pair" first or set PANORAMA_GATEWAY_CONFIG_PATH. (${String(error)})`);
+        throw new Error(`Gateway config not found. Run "pair" first or set --config-path / PANORAMA_GATEWAY_CONFIG_PATH. (${String(error)})`);
     }
     const supabaseUrl = resolveSupabaseUrl(options, config);
     const supabaseAnonKey = resolveSupabaseAnonKey(options, config);
@@ -1988,7 +2084,7 @@ async function startGateway(options) {
         supabaseAnonKey,
         deviceName,
     };
-    await saveConfig(config);
+    await saveConfig(config, options);
     const supabase = createClient(supabaseUrl, supabaseAnonKey, {
         auth: {
             persistSession: false,
@@ -2010,14 +2106,14 @@ async function startGateway(options) {
     }
     config.accessToken = sessionData.session.access_token;
     config.refreshToken = sessionData.session.refresh_token;
-    await saveConfig(config);
+    await saveConfig(config, options);
     supabase.auth.onAuthStateChange((event, session) => {
         if (!session)
             return;
         if (event === 'TOKEN_REFRESHED' || event === 'SIGNED_IN') {
             config.accessToken = session.access_token;
             config.refreshToken = session.refresh_token;
-            void saveConfig(config)
+            void saveConfig(config, options)
                 .then(() => logInfo('Gateway session refreshed'))
                 .catch((error) => {
                 logError('Failed to persist refreshed gateway session', {
@@ -2043,7 +2139,7 @@ async function startGateway(options) {
     });
     await sendHeartbeat(supabase, initialStatus, capabilities, deviceName);
     let heartbeatStatus = initialStatus;
-    await writePidFile(process.pid);
+    await writePidFile(process.pid, options);
     const heartbeatTimer = setInterval(() => {
         void sendHeartbeat(supabase, heartbeatStatus, capabilities, deviceName);
     }, DEFAULT_HEARTBEAT_INTERVAL_MS);
@@ -2149,7 +2245,7 @@ async function startGateway(options) {
         heartbeatStatus = 'offline';
         await sendHeartbeat(supabase, 'offline', capabilities, deviceName);
         await channel.unsubscribe();
-        await removePidFile();
+        await removePidFile(options);
         process.exit(0);
     };
     process.on('SIGINT', () => void shutdown('SIGINT'));
@@ -2162,15 +2258,16 @@ async function startGateway(options) {
         concurrency: GATEWAY_CONCURRENCY,
     });
 }
-async function stopGateway() {
-    const pid = readPidFile();
+async function stopGateway(options) {
+    const { pidPath } = resolveGatewayPaths(options);
+    const pid = readPidFile(options);
     if (!pid) {
-        logInfo('No gateway pid file found', { pidPath: PID_PATH });
+        logInfo('No gateway pid file found', { pidPath });
         return;
     }
     if (!isProcessAlive(pid)) {
         logInfo('Gateway not running, removing stale pid file', { pid });
-        await removePidFile();
+        await removePidFile(options);
         return;
     }
     try {
@@ -2188,7 +2285,7 @@ async function stopGateway() {
     const start = Date.now();
     while (Date.now() - start < timeoutMs) {
         if (!isProcessAlive(pid)) {
-            await removePidFile();
+            await removePidFile(options);
             logInfo('Gateway stopped', { pid });
             return;
         }
@@ -2196,19 +2293,45 @@ async function stopGateway() {
     }
     logInfo('Gateway stop timed out; process may still be running', { pid });
 }
+async function statusGateway(options) {
+    const { pidPath, logPath, configPath } = resolveGatewayPaths(options);
+    const pid = readPidFile(options);
+    const configExists = fsSync.existsSync(configPath);
+    if (!pid) {
+        logInfo('Gateway status', {
+            status: 'stopped',
+            pidPath,
+            logPath,
+            configPath,
+            configFound: configExists,
+        });
+        return;
+    }
+    const alive = isProcessAlive(pid);
+    logInfo('Gateway status', {
+        status: alive ? 'running' : 'stopped',
+        pid,
+        pidPath,
+        logPath,
+        configPath,
+        configFound: configExists,
+        stalePid: alive ? null : pid,
+    });
+}
 async function showLogs(options) {
     const linesRaw = getStringOption(options, 'lines');
     const lines = linesRaw ? Number.parseInt(linesRaw, 10) : 200;
     const follow = options['no-follow'] !== true;
+    const { logPath } = resolveGatewayPaths(options);
     try {
-        const content = await fs.readFile(LOG_PATH, 'utf-8');
+        const content = await fs.readFile(logPath, 'utf-8');
         const allLines = content.split(/\r?\n/);
         const tail = Number.isFinite(lines) && lines > 0 ? allLines.slice(-lines) : allLines;
         process.stdout.write(`${tail.join('\n')}\n`);
     }
     catch (error) {
         logError('Unable to read gateway log file', {
-            logPath: LOG_PATH,
+            logPath,
             error: error instanceof Error ? error.message : String(error),
         });
         return;
@@ -2217,22 +2340,22 @@ async function showLogs(options) {
         return;
     let position = 0;
     try {
-        const stat = await fs.stat(LOG_PATH);
+        const stat = await fs.stat(logPath);
         position = stat.size;
     }
     catch {
         position = 0;
     }
-    logInfo('Tailing gateway logs', { logPath: LOG_PATH });
-    fsSync.watch(LOG_PATH, { persistent: true }, async (event) => {
+    logInfo('Tailing gateway logs', { logPath });
+    fsSync.watch(logPath, { persistent: true }, async (event) => {
         if (event !== 'change')
             return;
         try {
-            const stat = await fs.stat(LOG_PATH);
+            const stat = await fs.stat(logPath);
             if (stat.size < position) {
                 position = 0;
             }
-            const handle = await fs.open(LOG_PATH, 'r');
+            const handle = await fs.open(logPath, 'r');
             const length = stat.size - position;
             if (length > 0) {
                 const buffer = Buffer.alloc(length);
@@ -2244,7 +2367,7 @@ async function showLogs(options) {
         }
         catch (error) {
             logError('Failed to tail gateway logs', {
-                logPath: LOG_PATH,
+                logPath,
                 error: error instanceof Error ? error.message : String(error),
             });
         }
@@ -2253,6 +2376,7 @@ async function showLogs(options) {
 }
 async function run() {
     const parsed = parseArgs(process.argv.slice(2));
+    ACTIVE_OPTIONS = parsed.options;
     if (parsed.options.h || parsed.options.help || parsed.command === null) {
         printHelp();
         return;
@@ -2272,7 +2396,11 @@ async function run() {
         return;
     }
     if (parsed.command === 'stop') {
-        await stopGateway();
+        await stopGateway(parsed.options);
+        return;
+    }
+    if (parsed.command === 'status') {
+        await statusGateway(parsed.options);
         return;
     }
     if (parsed.command === 'logs') {