@volter/supercode-teams 0.2.20

package/workspace-client.mjs

@@ -0,0 +1,171 @@
+const trimOrigin=value=>{const u=new URL(value),loopback=u.hostname==='localhost'||u.hostname==='::1'||u.hostname==='[::1]'||/^127(?:\.\d{1,3}){3}$/.test(u.hostname);if(!['http:','https:'].includes(u.protocol)||u.username||u.password||u.search||u.hash||(u.pathname!==''&&u.pathname!=='/')||(u.protocol==='http:'&&!loopback))throw new TypeError('server must be an HTTPS origin (HTTP is loopback-only)');return u.origin;};
+const randomKey=()=>globalThis.crypto.randomUUID().replaceAll('-','')+globalThis.crypto.randomUUID().replaceAll('-','');
+export class TeamsClient {
+  constructor({server,credential,fetch:fetchImpl=(...args)=>globalThis.fetch(...args)}){this.server=trimOrigin(server);this.credential=credential;this.fetch=fetchImpl;if(typeof fetchImpl!=='function')throw new TypeError('fetch is required');}
+  async request(method,path,{body,signal,idempotencyKey,ifMatch}={}) {
+    const key=idempotencyKey??(method==='GET'?null:randomKey());let delay=250,last;
+    for(let attempt=0;attempt<5;attempt++) { try {
+      const response=await this.fetch(this.server+path,{method,signal,redirect:'manual',headers:{Accept:'application/json',Authorization:`Bearer ${this.credential}`,...(body!==undefined?{'Content-Type':'application/json'}:{}),...(key?{'Idempotency-Key':key}:{}),...(ifMatch!==undefined?{'If-Match':String(ifMatch)}:{})},body:body===undefined?undefined:JSON.stringify(body)});
+      if(response.type==='opaqueredirect'||(response.status>=300&&response.status<400))throw Object.assign(new Error('cross-origin redirects are refused'),{code:'invalid_request',status:400,retryable:false});
+      const value=response.status===204?null:await response.json();if(!response.ok)throw Object.assign(new Error(value?.error?.message??`HTTP ${response.status}`),value?.error,{status:response.status});return value;
+    } catch(error) { last=error;if(method!=='GET'||signal?.aborted||!(!error.status||error.retryable)||attempt===4)throw error;await retryWait(delay,signal);delay=Math.min(delay*2,5000); } }
+    throw last;
+  }
+  me(options){return this.request('GET','/api/v1/me',options);} capabilities(options){return this.request('GET','/api/v1/capabilities',options);} team(id){return new TeamClient(this,id);}
+  teams(queryValue={},options){return this.request('GET','/api/v1/teams'+query(queryValue),options);}
+  createTeam(body,options){return this.request('POST','/api/v1/teams',{...options,body});}
+}
+const segment = value => {
+  if (typeof value !== 'string' || !value || value.length > 256) throw new TypeError('a nonempty resource ID is required');
+  return encodeURIComponent(value);
+};
+class TeamClient {
+  constructor(root, id) {
+    this.root = root; this.id = id;
+    const base = `/api/v1/teams/${segment(id)}`;
+    const get = (path, options) => root.request('GET', base + path, options);
+    const post = (path, body, options) => root.request('POST', base + path, { ...options, body });
+    const patch = (path, body, options) => root.request('PATCH', base + path, { ...options, body });
+    const remove = (path, options) => root.request('DELETE', base + path, options);
+    const resource = (path, id) => `${path}/${segment(id)}`;
+    this.sessions = {
+      list: (q = {}, o) => get('/sessions' + query(q), o),
+      search: (q, o) => get('/sessions/search' + query(q), o),
+      watch: (q = {}, o = {}) => events(root, base + '/sessions/events' + query(q), o),
+      get: id => new SessionClient(root, base, id),
+    };
+    this.members = {
+      list: (q = {}, o) => get('/members' + query(q), o),
+      update: (id, body, o) => patch(resource('/members', id), body, o),
+      remove: (id, o) => remove(resource('/members', id), o),
+    };
+    this.groups = {
+      list: (q = {}, o) => get('/groups' + query(q), o),
+      create: (body, o) => post('/groups', body, o),
+      remove: (id, o) => remove(resource('/groups', id), o),
+      addMember: (id, member, o) => root.request('PUT', base + resource('/groups', id) + resource('/members', member), o),
+      removeMember: (id, member, o) => remove(resource('/groups', id) + resource('/members', member), o),
+    };
+    this.machines = {
+      list: (q = {}, o) => get('/machines' + query(q), o),
+      get: (id, o) => get(resource('/machines', id), o),
+      create: (body, o) => post('/machines', body, o),
+      roots: (id, q = {}, o) => get(resource('/machines', id) + '/roots' + query(q), o),
+      remove: (id, o) => remove(resource('/machines', id), o),
+      liveGrants: machineId => {
+        const path = resource('/machines', machineId) + '/grants';
+        return {
+          list: (o) => get(path, o), get: (id, o) => get(resource(path, id), o),
+          create: (body, o) => post(path, body, o), remove: (id, o) => remove(resource(path, id), o),
+        };
+      },
+    };
+    this.sources = {
+      list: (q = {}, o) => get('/sources' + query(q), o),
+      get: (id, o) => get(resource('/sources', id), o),
+      create: (body, o) => post('/sources', body, o),
+      update: (id, body, o) => patch(resource('/sources', id), body, o),
+      credential: (id, body, o) => post(resource('/sources', id) + '/credentials', body, o),
+      configuration: (id, format = 'otel-collector', o) => get(resource('/sources', id) + '/config' + query({ format }), o),
+    };
+    this.syncRules = {
+      list: (q = {}, o) => get('/sync-rules' + query(q), o), get: (id, o) => get(resource('/sync-rules', id), o),
+      create: (body, o) => post('/sync-rules', body, o), update: (id, body, o) => patch(resource('/sync-rules', id), body, o),
+      remove: (id, o) => remove(resource('/sync-rules', id), o),
+    };
+    this.credentials = {
+      create: (body, o) => post('/credentials', body, o), remove: (id, o) => remove(resource('/credentials', id), o),
+    };
+    this.invitations = { create: (body, o) => post('/invitations', body, o) };
+    this.operations = { get: (id, o) => get(resource('/operations', id), o) };
+    this.continuations = {
+      get: (id, o) => get(resource('/continuations', id), o),
+      authorizeDestination: (id, body, o) => post(resource('/continuations', id) + '/authorize-destination', body, o),
+      launch: (id, o) => post(resource('/continuations', id) + '/launch', undefined, o),
+      completeLocal: (id, body, o) => post(resource('/continuations', id) + '/complete-local', body, o),
+    };
+    this.attachments = {
+      actions: (id, body, o) => post(resource('/attachments', id) + '/actions', body, o),
+      detach: (id, o) => remove(resource('/attachments', id), o),
+      stream: (attachment, o = {}) => attachmentEvents(root, base, attachment, o),
+    };
+  }
+}
+class SessionClient {
+  constructor(root, base, id) { this.root = root; this.path = `${base}/sessions/${segment(id)}`; }
+  descriptor = o => this.root.request('GET', this.path, o);
+  read = (q = {}, o) => this.root.request('GET', this.path + '/messages' + query(q), o);
+  follow = (q = {}, o = {}) => events(this.root, this.path + '/events' + query(q), o);
+  access = o => this.root.request('GET', this.path + '/access', o);
+  grant = (body, o) => this.root.request('POST', this.path + '/access', { ...o, body });
+  revoke = (id, o) => this.root.request('DELETE', this.path + '/access/' + segment(id), o);
+  export = (body, o) => this.root.request('POST', this.path + '/exports', { ...o, body });
+  prepare = (body, o) => this.root.request('POST', this.path + '/continuations', { ...o, body });
+  attach = (body, o) => this.root.request('POST', this.path + '/attachments', { ...o, body });
+  artifact = async (id, { signal, range } = {}) => {
+    if (range !== undefined && !/^bytes=(?:[0-9]+-[0-9]*|-[0-9]+)$/.test(range)) throw new TypeError('range must be one byte range');
+    const response = await this.root.fetch(this.root.server + this.path + '/artifacts/' + segment(id), {
+      signal, redirect: 'manual', headers: { Authorization: `Bearer ${this.root.credential}`, ...(range ? { Range: range } : {}) },
+    });
+    rejectRedirect(response);
+    if (!response.ok) throw await sseError(response);
+    return response;
+  };
+}
+function rejectRedirect(response) {
+  if (response.type === 'opaqueredirect' || response.status >= 300 && response.status < 400) throw Object.assign(new Error('cross-origin redirects are refused'), { code: 'invalid_request', status: 400, retryable: false });
+}
+async function* attachmentEvents(root, base, attachment, { signal } = {}) {
+  const expected = root.server + base + '/attachments/' + segment(attachment.id) + '/stream';
+  if (attachment.stream_format !== 'observed_runtime_event' || attachment.stream_url !== expected || typeof attachment.credential !== 'string' || !attachment.credential) throw new TypeError('attachment stream target or credential is invalid');
+  let response;
+  try {
+    response = await root.fetch(expected, { signal, redirect: 'manual', headers: { Accept: 'text/event-stream', Authorization: `Bearer ${attachment.credential}` } });
+    rejectRedirect(response);
+    if (!response.ok) throw await sseError(response);
+    let buffer = '';
+    for await (const chunk of response.body.pipeThrough(new TextDecoderStream())) {
+      buffer += chunk;
+      let match;
+      while ((match = /\r?\n\r?\n/.exec(buffer))) {
+        const block = buffer.slice(0, match.index); buffer = buffer.slice(match.index + match[0].length);
+        if (new TextEncoder().encode(block).length > 1024 * 1024 + 4096) throw Object.assign(new Error('attachment frame exceeds 1 MiB'), { code: 'resync_required', retryable: false });
+        const lines = block.split(/\r?\n/), kind = lines.find(line => line.startsWith('event:'))?.slice(6).trim();
+        const data = lines.filter(line => line.startsWith('data:')).map(line => line.slice(5).replace(/^ /, '')).join('\n');
+        if (!data) continue;
+        if (kind === 'access_revoked' || kind === 'resync_required') throw Object.assign(new Error(`attachment stream ${kind}`), { code: kind, retryable: false });
+        if (kind !== 'runtime') throw Object.assign(new Error('unexpected attachment stream event'), { code: 'invalid_request', retryable: false });
+        const frame = JSON.parse(data);
+        yield frame;
+        if (frame.type === 'closed' || frame.type === 'error' && frame.terminal) return;
+      }
+      if (new TextEncoder().encode(buffer).length > 1024 * 1024 + 4096) throw Object.assign(new Error('attachment frame exceeds 1 MiB'), { code: 'resync_required', retryable: false });
+    }
+    if (!signal?.aborted) throw Object.assign(new Error('attachment stream ended; create a new attachment to reconnect'), { code: 'resync_required', retryable: false });
+  } catch (error) { if (!signal?.aborted) throw error; }
+}
+const query=q=>{const p=new URLSearchParams();for(const [k,v]of Object.entries(q))if(v!==undefined)p.set(k,String(v));return p.size?'?'+p:'';};
+const retryWait=(delay,signal)=>new Promise((resolve,reject)=>{const done=()=>{signal?.removeEventListener('abort',abort);resolve();},timer=setTimeout(done,delay),abort=()=>{clearTimeout(timer);signal?.removeEventListener('abort',abort);reject(signal.reason);};signal?.addEventListener('abort',abort,{once:true});});
+async function sseError(response){let value=null;try{value=await response.json();}catch{}return Object.assign(new Error(value?.error?.message??`SSE HTTP ${response.status}`),value?.error,{status:response.status,retryable:value?.error?.retryable??(response.status===429||response.status>=500)});}
+async function* events(root,path,{signal,after}={}){
+  let cursor=after??null,lastYielded=null,lastError=null;
+  for(let attempt=0;attempt<5&&!signal?.aborted;attempt++){
+    const suffix=cursor?path+(path.includes('?')?'&':'?')+'after='+encodeURIComponent(cursor):path;
+    try{
+      const response=await root.fetch(root.server+suffix,{signal,redirect:'manual',headers:{Accept:'text/event-stream',Authorization:`Bearer ${root.credential}`,...(cursor?{'Last-Event-ID':cursor}:{})}});
+      if(response.type==='opaqueredirect'||response.status>=300&&response.status<400)throw Object.assign(new Error('cross-origin redirects are refused'),{code:'invalid_request',status:400,retryable:false});
+      if(!response.ok)throw await sseError(response);
+      let buffer='';
+      for await(const chunk of response.body.pipeThrough(new TextDecoderStream())){
+        buffer+=chunk;let at;
+        while((at=buffer.indexOf('\n\n'))>=0){
+          const block=buffer.slice(0,at);buffer=buffer.slice(at+2);const id=block.split('\n').find(line=>line.startsWith('id: '))?.slice(4),data=block.split('\n').filter(line=>line.startsWith('data: ')).map(line=>line.slice(6)).join('\n');if(!data)continue;
+          const event=JSON.parse(data),terminal=event?.terminal||event?.type==='access_revoked'||event?.type==='resync_required',nextCursor=id??cursor;cursor=nextCursor;if(!terminal&&nextCursor&&nextCursor===lastYielded)continue;if(nextCursor)lastYielded=nextCursor;yield event;if(terminal)return;
+        }
+      }
+      lastError=Object.assign(new Error('SSE stream ended before a terminal event'),{retryable:true});
+    }catch(error){if(signal?.aborted)return;if(error.retryable===false||error.status&&error.status!==429&&error.status<500)throw error;lastError=error;}
+    if(attempt<4)await retryWait(Math.min(250*2**attempt,5000),signal).catch(()=>{});
+  }
+  if(!signal?.aborted&&lastError)throw lastError;
+}

package/workspace-move.mjs

@@ -0,0 +1,38 @@
+// A project moving from one machine to another (docs/plans/remote-execution.md, decision 4),
+// shared by `teams workspace move` and `sessions continue --workspace-from`. Both machines must
+// run no exec jobs; the destination publishes only when every byte arrived (execution.mjs).
+import { createHash } from 'node:crypto';
+import { openMachine } from './machine-door.mjs';
+import { nodeRpc } from './client.mjs';
+
+/** `from`/`to` are machine names, or null for this machine's own daemon. */
+export async function moveWorkspace({ from, to, path, toPath = path, context = null, home }) {
+  const [source$, sink$] = await Promise.all([from, to].map((machine) => openMachine({ machine, context, home })));
+  const fail = (message) => Object.assign(new Error(message), { code: 'conflict', exitCode: 1 });
+  try {
+    for (const [name, channel] of [[from ?? 'this machine', source$], [to ?? 'this machine', sink$]]) {
+      const { jobs } = await (await nodeRpc(channel)).call('jobs.list', {});
+      if (jobs.some((job) => job.kind === 'exec')) throw fail(`${name} runs exec jobs; a workspace moves between quiet machines`);
+    }
+    // The destination opens first; the source sends nothing until {start: true}, written once
+    // its listeners are attached.
+    const sink = await sink$.open('workspace', { op: 'import', path: toPath });
+    const answered = new Promise((resolveSink) => sink.on('close', resolveSink));
+    const hash = createHash('sha256');
+    let bytes = 0;
+    const source = await source$.open('workspace', { op: 'export', path });
+    source.on('data', (chunk) => { const data = Buffer.from(chunk, 'base64'); hash.update(data); bytes += data.length; if (!sink.closed) sink.write(chunk); });
+    const exported = new Promise((resolveEnd) => source.on('close', resolveEnd));
+    source.write(JSON.stringify({ start: true }));
+    const reason = await Promise.race([exported, answered.then((why) => `destination closed: ${why}`)]);
+    const sha256 = hash.digest('hex');
+    if (reason !== 'end') { sink.close('abort'); source.close('abort'); throw fail(`workspace not moved: ${reason}`); }
+    sink.write(JSON.stringify({ commit: sha256 }));
+    const outcome = await answered;
+    if (!String(outcome).startsWith('published')) throw fail(`workspace not moved: ${outcome}`);
+    return { from: from ?? 'local', to: to ?? 'local', path: toPath, bytes, sha256 };
+  } finally {
+    await new Promise((r) => setTimeout(r, 200));
+    source$.close(); sink$.close();
+  }
+}