@volter/supercode-teams 0.2.177 → 0.2.178

package/bin/teams.mjs

@@ -307,12 +307,13 @@ async function main() {
     case 'workspace': {
       if (sub === 'list') return withNode(async (rpc) => out(await rpc.call('workspace.list', {})));
       if (sub === 'register' && rest[0]) return withNode(async (rpc) => out(await rpc.call('workspace.register', { path: rest[0], repository: flags.repo ?? null })));
+      if (sub === 'unregister' && rest[0]) return withNode(async (rpc) => out(await rpc.call('workspace.unregister', { path: rest[0] })));
       if (sub === 'resolve' && rest[0]) return withNode(async (rpc) => out(await rpc.call('workspace.resolve', { repository: rest[0], branch: flags.branch ?? null, solo: Boolean(flags.solo), card: flags.card ?? null, create: Boolean(flags.create) })));
       if (sub === 'inspect' && rest[0]) return withNode(async (rpc) => out(await rpc.call('workspace.inspect', { path: rest[0] })));
       // `workspace move --from A --to B --path P [--to-path Q]`: the project leaves A and arrives
       // at B, published there only if every byte arrived (sha256 on commit) and neither machine
       // runs an exec job. A is left as it was; B's path must not exist.
-      if (sub !== 'move' || !flags.from || !flags.to || !flags.path) die('workspace move --from MACHINE --to MACHINE --path P [--to-path Q]');
+      if (sub !== 'move' || !flags.from || !flags.to || !flags.path) die('workspace list | register PATH [--repo R] | unregister PATH | resolve REPO | inspect PATH | move --from MACHINE --to MACHINE --path P [--to-path Q]');
       try {
         out(await moveWorkspace({ from: String(flags.from), to: String(flags.to), path: String(flags.path), toPath: String(flags['to-path'] ?? flags.path), context: flags.context ? String(flags.context) : null, home }));
       } catch (error) { die(error.message, error.exitCode ?? 1); }

package/machine.mjs

@@ -1799,11 +1799,12 @@ export class TeamsMachine extends MachineCore {
         act('title', params.target, 'ok', renamed);
         return { ok: true, target: params.target, title: params.title ?? null, window: renamed };
       }
-      case 'workspace.inspect': case 'workspace.register': case 'workspace.list': case 'workspace.resolve': {
+      case 'workspace.inspect': case 'workspace.register': case 'workspace.unregister': case 'workspace.list': case 'workspace.resolve': {
         if (!operator) throw Object.assign(new Error('operators only'), { code: 403 });
         const registry = new Workspaces(this.home);
         const result = method === 'workspace.inspect' ? inspectCheckout(params.path)
           : method === 'workspace.register' ? registry.register(params.path, params.repository)
+          : method === 'workspace.unregister' ? registry.unregister(params.path)
           : method === 'workspace.list' ? registry.list()
           : registry.resolve(params.repository, params.branch, { solo: params.solo, card: params.card, create: params.create });
         act('workspace', '*', 'ok', method);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@volter/supercode-teams",
-  "version": "0.2.177",
+  "version": "0.2.178",
   "type": "module",
   "description": "A machine daemon serving this machine's doors, and a local or remote Teams server for shared session discovery, OpenTelemetry ingestion and access to enrolled machines.",
   "license": "MIT",

package/workspaces.mjs

@@ -25,18 +25,27 @@ export function inspectCheckout(path) {
 }
 export class Workspaces {
   constructor(home) { this.file = join(home, 'workspaces.jsonl'); }
-  list() {
+  // Every registration stands until its checkout is registered again or unregistered; the newest standing row
+  // answers each repository and branch (list). Unregistering a registration made by mistake therefore gives back
+  // the one it replaced; the removal row stays in the file as the record of that act.
+  standing() {
     let text; try { text = readFileSync(this.file, 'utf8'); } catch (e) { if (e.code === 'ENOENT') return []; throw e; }
-    const map = new Map();
+    let standing = [];
     for (const line of text.split('\n').filter(Boolean)) {
       let row; try { row = JSON.parse(line); } catch { throw new Error(`invalid machine workspace map ${this.file}`); }
-      for (const [key, old] of map) {
-        if (old.path === row.path) map.delete(key);
-        else if (row.primary && old.repository === row.repository) old.primary = false;
-      }
-      map.set(`${row.repository}\n${row.branch ?? ''}`, row);
+      standing = standing.filter((old) => old.path !== row.path);
+      if (!row.removed) standing.push(row);
     }
-    return [...map.values()];
+    return standing;
+  }
+  list() {
+    const map = new Map();
+    for (const row of this.standing()) { const key = `${row.repository}\n${row.branch ?? ''}`; map.delete(key); map.set(key, { ...row }); }
+    // A repository's main checkout is its newest registered main checkout that stands.
+    const rows = [...map.values()], main = new Map();
+    for (const row of rows) if (row.primary) main.set(row.repository, row);
+    for (const row of rows) row.primary = main.get(row.repository) === row;
+    return rows;
   }
   register(path, repository = null) {
     const info = inspectCheckout(path), id = repositoryId(repository ?? info.repository);
@@ -46,6 +55,16 @@ export class Workspaces {
     appendFileSync(this.file, JSON.stringify(row) + '\n', { mode: 0o600 });
     return row;
   }
+  // A registration made by mistake is removed: the checkout at `path` (its root, as registered) leaves the map. The
+  // checkout itself is untouched.
+  unregister(path) {
+    let at = resolve(path);
+    try { at = inspectCheckout(path).root; } catch { try { at = realpathSync(at); } catch { /* a path that no longer exists */ } }
+    const row = this.standing().findLast(r => r.path === at || r.path === resolve(path));
+    if (!row) throw new Error(`${path} is not registered in this machine's workspace map`);
+    appendFileSync(this.file, JSON.stringify({ path: row.path, removed: true, repository: row.repository, branch: row.branch }) + '\n', { mode: 0o600 });
+    return { ...row, removed: true };
+  }
   resolve(repository, branch = null, { solo = false, card = null, create = false } = {}) {
     const id = repositoryId(repository), rows = this.list().filter(r => r.repository === id);
     if (!rows.length) throw new Error(`repository ${id} is missing from this machine's workspace map; register its checkout with teams workspace register <path>`);