amalgm 0.1.36 → 0.1.37

package/runtime/scripts/amalgm-mcp/workspace/rest.js

@@ -8,6 +8,13 @@ const path = require('path');
 const { execFile } = require('child_process');
 const { promisify } = require('util');
 const { AMALGM_DIR, DEFAULT_CWD } = require('../config');
+const activeMemory = require('../../chat-core/tooling/active-memory');
+const {
+  listWorkspaces,
+  removeWorkspace,
+  renameWorkspace,
+  upsertWorkspace,
+} = require('./store');
 
 const execFileAsync = promisify(execFile);
 const MAX_BUFFER = 10 * 1024 * 1024;
@@ -41,6 +48,16 @@ async function ensureWorkspaceRoot() {
   return workspaceRoot;
 }
 
+function ensureProjectMemory(workspace, source = 'workspace') {
+  if (!workspace) return;
+  activeMemory.ensureConstructMemory({
+    type: 'project',
+    id: workspace.id,
+    name: workspace.name,
+    projectPath: workspace.path,
+  }, { source });
+}
+
 async function uniqueProjectPath(workspaceRoot, requestedName) {
   const name = sanitizeProjectName(requestedName);
   let candidate = path.join(workspaceRoot, name);
@@ -60,6 +77,11 @@ function isValidWorkspacePath(workspacePath) {
   return typeof workspacePath === 'string' && workspacePath.length > 0 && path.isAbsolute(workspacePath);
 }
 
+function shouldRefreshBranches(query) {
+  const value = query?.refresh;
+  return value === true || value === 'true' || value === '1' || value === 'yes';
+}
+
 async function runGit(args, cwd) {
   try {
     const { stdout, stderr } = await execFileAsync('git', args, {
@@ -137,28 +159,100 @@ function getLocalWorktreePath(workspacePath, shortId) {
 
 async function handleProjects(sendJson) {
   try {
-    const rootDir = await ensureWorkspaceRoot();
-    const dirents = await fs.promises.readdir(rootDir, { withFileTypes: true }).catch(() => []);
-    const projects = [];
+    const rootDir = getWorkspaceRoot();
+    const projects = await Promise.all(
+      listWorkspaces().map(async (workspace) => ({
+        ...workspace,
+        branch: workspace.path ? await readBranch(workspace.path) : null,
+      })),
+    );
 
-    for (const dirent of dirents) {
-      if (!dirent.isDirectory() || dirent.name.startsWith('.')) continue;
+    projects.sort((a, b) => a.name.localeCompare(b.name));
+    sendJson(200, { projects, workspaceRoot: rootDir });
+  } catch (error) {
+    sendJson(500, {
+      error: error instanceof Error ? error.message : 'Failed to list workspaces',
+    });
+  }
+}
 
-      const projectPath = path.join(rootDir, dirent.name);
-      const branch = await readBranch(projectPath);
+async function handleProjectRegister(body, sendJson) {
+  const workspacePath = body?.path || body?.source_path;
+  const name = body?.name || body?.project_name;
 
-      projects.push({
-        name: dirent.name,
-        path: projectPath,
-        branch,
-      });
+  if (!workspacePath || typeof workspacePath !== 'string') {
+    sendJson(400, { error: 'path is required' });
+    return;
+  }
+
+  if (!path.isAbsolute(workspacePath)) {
+    sendJson(400, { error: 'path must be absolute' });
+    return;
+  }
+
+  try {
+    const sourceStats = await fs.promises.stat(workspacePath);
+    if (!sourceStats.isDirectory()) {
+      sendJson(400, { error: 'path must be a folder' });
+      return;
     }
 
-    projects.sort((a, b) => a.name.localeCompare(b.name));
-    sendJson(200, { projects, workspaceRoot: rootDir });
+    const workspaceRoot = await ensureWorkspaceRoot();
+    const workspace = upsertWorkspace({
+      path: await fs.promises.realpath(workspacePath),
+      name,
+      source: body?.source || 'computer',
+    }, {
+      workspaceRoot,
+      source: 'workspace:register',
+    });
+    ensureProjectMemory(workspace, 'workspace:register');
+
+    sendJson(200, {
+      success: true,
+      workspace,
+      path: workspace.path,
+      name: workspace.name,
+      uri: workspace.uri,
+      workspaceRoot,
+    });
   } catch (error) {
     sendJson(500, {
-      error: error instanceof Error ? error.message : 'Failed to list workspaces',
+      error: error instanceof Error ? error.message : 'Failed to register workspace',
+    });
+  }
+}
+
+async function handleProjectUpdate(body, sendJson) {
+  const identifier = body?.id || body?.path;
+  if (!identifier || typeof identifier !== 'string') {
+    sendJson(400, { error: 'id or path is required' });
+    return;
+  }
+
+  try {
+    const workspace = renameWorkspace(identifier, body?.name, { source: 'workspace:update' });
+    ensureProjectMemory(workspace, 'workspace:update');
+    sendJson(200, { success: true, workspace, path: workspace.path, name: workspace.name });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : 'Failed to update workspace';
+    sendJson(message === 'Workspace not found' ? 404 : 500, { error: message });
+  }
+}
+
+async function handleProjectDelete(body, sendJson) {
+  const identifier = body?.id || body?.path;
+  if (!identifier || typeof identifier !== 'string') {
+    sendJson(400, { error: 'id or path is required' });
+    return;
+  }
+
+  try {
+    const workspace = removeWorkspace(identifier, { source: 'workspace:delete' });
+    sendJson(200, { success: true, workspace });
+  } catch (error) {
+    sendJson(500, {
+      error: error instanceof Error ? error.message : 'Failed to remove workspace',
     });
   }
 }
@@ -191,10 +285,21 @@ async function handleImport(body, sendJson) {
     ]);
 
     if (isWithin(realWorkspaceRoot, realSource)) {
+      const workspace = upsertWorkspace({
+        path: realSource,
+        name: projectName || path.basename(realSource),
+        source: 'managed',
+        managed: true,
+      }, {
+        workspaceRoot,
+        source: 'workspace:import',
+      });
+      ensureProjectMemory(workspace, 'workspace:import');
       sendJson(200, {
         success: true,
-        path: realSource,
-        name: path.basename(realSource),
+        path: workspace.path,
+        name: workspace.name,
+        workspace,
         workspaceRoot,
         alreadyInWorkspace: true,
       });
@@ -211,11 +316,22 @@ async function handleImport(body, sendJson) {
       errorOnExist: true,
       dereference: false,
     });
+    const workspace = upsertWorkspace({
+      path: targetPath,
+      name: path.basename(targetPath),
+      source: 'managed',
+      managed: true,
+    }, {
+      workspaceRoot,
+      source: 'workspace:import',
+    });
+    ensureProjectMemory(workspace, 'workspace:import');
 
     sendJson(200, {
       success: true,
-      path: targetPath,
-      name: path.basename(targetPath),
+      path: workspace.path,
+      name: workspace.name,
+      workspace,
       workspaceRoot,
       alreadyInWorkspace: false,
     });
@@ -247,7 +363,17 @@ async function handleClone(body, sendJson) {
   try {
     await fs.promises.access(targetPath);
     if (await isGitRepo(targetPath)) {
-      sendJson(200, { success: true, path: targetPath, workspaceRoot, alreadyExists: true });
+      const workspace = upsertWorkspace({
+        path: targetPath,
+        name: repoName,
+        source: 'github',
+        managed: true,
+      }, {
+        workspaceRoot,
+        source: 'workspace:clone',
+      });
+      ensureProjectMemory(workspace, 'workspace:clone');
+      sendJson(200, { success: true, path: workspace.path, workspace, workspaceRoot, alreadyExists: true });
       return;
     }
     sendJson(409, {
@@ -273,7 +399,18 @@ async function handleClone(body, sendJson) {
     return;
   }
 
-  sendJson(200, { success: true, path: targetPath, workspaceRoot, alreadyExists: false });
+  const workspace = upsertWorkspace({
+    path: targetPath,
+    name: repoName,
+    source: 'github',
+    managed: true,
+  }, {
+    workspaceRoot,
+    source: 'workspace:clone',
+  });
+  ensureProjectMemory(workspace, 'workspace:clone');
+
+  sendJson(200, { success: true, path: workspace.path, workspace, workspaceRoot, alreadyExists: false });
 }
 
 async function handleBranches(query, sendJson) {
@@ -290,7 +427,7 @@ async function handleBranches(query, sendJson) {
 
   const remoteResult = await runGit(['remote'], workspacePath);
   const hasRemote = remoteResult.stdout.trim().length > 0;
-  if (hasRemote) {
+  if (hasRemote && shouldRefreshBranches(query)) {
     await runGit(['fetch', '--prune'], workspacePath);
   }
 
@@ -486,6 +623,9 @@ async function handleWorktreeDelete(body, sendJson) {
 
 module.exports = {
   handleProjects,
+  handleProjectRegister,
+  handleProjectUpdate,
+  handleProjectDelete,
   handleImport,
   handleClone,
   handleBranches,

package/runtime/scripts/amalgm-mcp/workspace/store.js

@@ -0,0 +1,278 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { AMALGM_COMPUTER_ID } = require('../config');
+const { openLocalDb } = require('../state/db');
+const { insertStateEvent, publishStateEvent } = require('../state/events');
+
+function cleanString(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : '';
+}
+
+function stableComputerId(input) {
+  return cleanString(input) || cleanString(AMALGM_COMPUTER_ID) || 'local-computer';
+}
+
+function encodePathForUri(localPath) {
+  return localPath
+    .split(path.sep)
+    .map((segment) => encodeURIComponent(segment))
+    .join('/');
+}
+
+function workspaceUriForPath(localPath, computerId) {
+  const normalizedPath = path.resolve(localPath);
+  return `computer://${encodeURIComponent(stableComputerId(computerId))}${encodePathForUri(normalizedPath)}`;
+}
+
+function workspaceIdForUri(uri) {
+  return `ws_${crypto.createHash('sha256').update(uri).digest('hex').slice(0, 20)}`;
+}
+
+function isWithin(root, target) {
+  const relative = path.relative(root, target);
+  return relative === '' || (!!relative && !relative.startsWith('..') && !path.isAbsolute(relative));
+}
+
+function isManagedWorkspacePath(localPath, workspaceRoot) {
+  const root = cleanString(workspaceRoot);
+  if (!root) return false;
+  return isWithin(path.resolve(root), path.resolve(localPath));
+}
+
+function basename(localPath) {
+  return path.basename(String(localPath || '').replace(/\/+$/, '')) || 'workspace';
+}
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function parseJson(value, fallback) {
+  if (typeof value !== 'string' || !value) return fallback;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
+function normalizeWorkspaceRecord(input, options = {}) {
+  const localPath = cleanString(input.path || input.localPath || input.local_path);
+  if (!localPath || !path.isAbsolute(localPath)) {
+    throw new Error('Workspace path must be an absolute local path');
+  }
+
+  const resolvedPath = path.resolve(localPath);
+  const computerId = stableComputerId(input.computerId || input.computer_id || options.computerId);
+  const uri = cleanString(input.uri) || workspaceUriForPath(resolvedPath, computerId);
+  const id = cleanString(input.id) || workspaceIdForUri(uri);
+  const createdAt = cleanString(input.createdAt || input.created_at) || nowIso();
+  const updatedAt = nowIso();
+  const managed = input.managed !== undefined
+    ? Boolean(input.managed)
+    : isManagedWorkspacePath(resolvedPath, options.workspaceRoot);
+  const status = cleanString(input.status) || (fs.existsSync(resolvedPath) ? 'ready' : 'missing');
+  const source = cleanString(input.source) || (managed ? 'managed' : 'computer');
+  const name = cleanString(input.name) || basename(resolvedPath);
+
+  return {
+    id,
+    name,
+    uri,
+    path: resolvedPath,
+    localPath: resolvedPath,
+    locationType: 'computer',
+    computerId,
+    source,
+    managed,
+    status,
+    createdAt,
+    updatedAt,
+    location: {
+      type: 'computer',
+      computerId,
+      path: resolvedPath,
+    },
+  };
+}
+
+function rowToWorkspace(row) {
+  if (!row) return null;
+  const parsed = parseJson(row.workspace_json, {});
+  return {
+    ...parsed,
+    id: row.id,
+    name: row.name,
+    uri: row.uri,
+    path: row.path,
+    localPath: row.path,
+    locationType: row.location_type,
+    computerId: row.computer_id || parsed.computerId || null,
+    source: row.source,
+    managed: row.managed === 1,
+    status: row.status,
+    createdAt: row.created_at,
+    updatedAt: row.updated_at,
+  };
+}
+
+function publishWorkspaceEvents(database, op, workspace, source) {
+  const events = [
+    insertStateEvent(database, {
+      resource: 'workspaces',
+      op,
+      id: workspace.id,
+      value: op === 'delete' ? undefined : workspace,
+      source,
+    }),
+    insertStateEvent(database, {
+      resource: 'projects',
+      op,
+      id: workspace.id,
+      value: op === 'delete' ? undefined : workspace,
+      source,
+    }),
+  ];
+  return events.filter(Boolean);
+}
+
+function publishEvents(events) {
+  for (const event of events) publishStateEvent(event);
+}
+
+function listWorkspaces() {
+  return openLocalDb()
+    .prepare('SELECT * FROM workspaces ORDER BY lower(name), path')
+    .all()
+    .map(rowToWorkspace)
+    .filter(Boolean);
+}
+
+function upsertWorkspace(input, options = {}) {
+  const db = openLocalDb();
+  let workspace;
+  let events = [];
+
+  db.transaction(() => {
+    workspace = normalizeWorkspaceRecord(input, options);
+    const existing = db
+      .prepare('SELECT * FROM workspaces WHERE id = ? OR uri = ? OR path = ? LIMIT 1')
+      .get(workspace.id, workspace.uri, workspace.path);
+    if (existing) {
+      const old = rowToWorkspace(existing);
+      workspace = {
+        ...old,
+        ...workspace,
+        id: old.id,
+        uri: old.uri || workspace.uri,
+        createdAt: old.createdAt || workspace.createdAt,
+        updatedAt: nowIso(),
+      };
+    }
+
+    db.prepare(`
+      INSERT INTO workspaces (
+        id,
+        name,
+        uri,
+        path,
+        location_type,
+        computer_id,
+        source,
+        managed,
+        status,
+        created_at,
+        updated_at,
+        workspace_json
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+      ON CONFLICT(id) DO UPDATE SET
+        name = excluded.name,
+        uri = excluded.uri,
+        path = excluded.path,
+        location_type = excluded.location_type,
+        computer_id = excluded.computer_id,
+        source = excluded.source,
+        managed = excluded.managed,
+        status = excluded.status,
+        updated_at = excluded.updated_at,
+        workspace_json = excluded.workspace_json
+    `).run(
+      workspace.id,
+      workspace.name,
+      workspace.uri,
+      workspace.path,
+      workspace.locationType,
+      workspace.computerId,
+      workspace.source,
+      workspace.managed ? 1 : 0,
+      workspace.status,
+      workspace.createdAt,
+      workspace.updatedAt,
+      JSON.stringify(workspace),
+    );
+
+    events = publishWorkspaceEvents(db, existing ? 'update' : 'insert', workspace, options.source || 'workspace:upsert');
+  })();
+
+  publishEvents(events);
+  return workspace;
+}
+
+function renameWorkspace(identifier, name, options = {}) {
+  const trimmedName = cleanString(name);
+  if (!trimmedName) throw new Error('Workspace name is required');
+
+  const db = openLocalDb();
+  let workspace = null;
+  let events = [];
+
+  db.transaction(() => {
+    const row = db.prepare('SELECT * FROM workspaces WHERE id = ? OR path = ? LIMIT 1').get(identifier, identifier);
+    if (!row) throw new Error('Workspace not found');
+    workspace = {
+      ...rowToWorkspace(row),
+      name: trimmedName,
+      updatedAt: nowIso(),
+    };
+    db.prepare(`
+      UPDATE workspaces
+      SET name = ?, updated_at = ?, workspace_json = ?
+      WHERE id = ?
+    `).run(workspace.name, workspace.updatedAt, JSON.stringify(workspace), workspace.id);
+    events = publishWorkspaceEvents(db, 'update', workspace, options.source || 'workspace:rename');
+  })();
+
+  publishEvents(events);
+  return workspace;
+}
+
+function removeWorkspace(identifier, options = {}) {
+  const db = openLocalDb();
+  let workspace = null;
+  let events = [];
+
+  db.transaction(() => {
+    const row = db.prepare('SELECT * FROM workspaces WHERE id = ? OR path = ? LIMIT 1').get(identifier, identifier);
+    if (!row) return;
+    workspace = rowToWorkspace(row);
+    db.prepare('DELETE FROM workspaces WHERE id = ?').run(workspace.id);
+    events = publishWorkspaceEvents(db, 'delete', workspace, options.source || 'workspace:remove');
+  })();
+
+  publishEvents(events);
+  return workspace;
+}
+
+module.exports = {
+  listWorkspaces,
+  normalizeWorkspaceRecord,
+  removeWorkspace,
+  renameWorkspace,
+  upsertWorkspace,
+  workspaceIdForUri,
+  workspaceUriForPath,
+};

package/runtime/scripts/chat-core/adapters/codex.js

@@ -19,6 +19,8 @@ class JsonLineRpc {
     this.pending = new Map();
     this.handlers = new Set();
     this.buffer = '';
+    this.closed = false;
+    this.closeError = null;
     this.child = spawn(binary, ['app-server'], {
       cwd,
       env,
@@ -33,13 +35,32 @@ class JsonLineRpc {
       const text = String(chunk || '').trim();
       if (text && process.env.CHAT_CORE_DEBUG) console.warn('[Codex]', text.slice(0, 1000));
     });
+    this.child.on('error', (err) => {
+      this.failAll(err);
+    });
     this.child.on('exit', (code, signal) => {
       const err = new Error(`codex app-server exited (${code ?? signal ?? 'unknown'})`);
-      for (const pending of this.pending.values()) pending.reject(err);
-      this.pending.clear();
+      this.failAll(err);
+    });
+    this.child.stdin.on('error', (err) => {
+      this.failAll(err);
     });
   }
 
+  failAll(err) {
+    this.closed = true;
+    this.closeError = err;
+    for (const pending of this.pending.values()) pending.reject(err);
+    this.pending.clear();
+  }
+
+  rejectPending(id, err) {
+    const pending = this.pending.get(id);
+    if (!pending) return;
+    this.pending.delete(id);
+    pending.reject(err);
+  }
+
   onData(chunk) {
     this.buffer += chunk;
     const lines = this.buffer.split('\n');
@@ -64,8 +85,12 @@ class JsonLineRpc {
   }
 
   request(method, params = {}, timeoutMs = 180000) {
+    if (this.closeError) return Promise.reject(this.closeError);
+    if (this.closed || this.child.exitCode !== null || this.child.signalCode !== null) {
+      return Promise.reject(new Error('codex app-server is not running'));
+    }
     const id = this.id++;
-    this.child.stdin.write(`${JSON.stringify({ id, method, params })}\n`);
+    const payload = `${JSON.stringify({ id, method, params })}\n`;
     return new Promise((resolve, reject) => {
       const timer = setTimeout(() => {
         this.pending.delete(id);
@@ -75,11 +100,26 @@ class JsonLineRpc {
         resolve: (value) => { clearTimeout(timer); resolve(value); },
         reject: (err) => { clearTimeout(timer); reject(err); },
       });
+      try {
+        this.child.stdin.write(payload, (err) => {
+          if (err) this.rejectPending(id, err);
+        });
+      } catch (err) {
+        this.rejectPending(id, err);
+      }
     });
   }
 
   notify(method, params) {
-    this.child.stdin.write(`${JSON.stringify(params === undefined ? { method } : { method, params })}\n`);
+    if (this.closed || this.child.exitCode !== null || this.child.signalCode !== null) return;
+    const payload = `${JSON.stringify(params === undefined ? { method } : { method, params })}\n`;
+    try {
+      this.child.stdin.write(payload, (err) => {
+        if (err) this.failAll(err);
+      });
+    } catch (err) {
+      this.failAll(err);
+    }
   }
 
   on(handler) {