@gizai/cli 2.0.1 → 2.1.0

package/cli/mcp-stdio-client.mjs

@@ -1,81 +0,0 @@
-// The Agent runtime's stdio MCP client. It runs in the person's Computer as
-// `node --input-type=module -e <this source> <request JSON> <server argv...>`: it starts the server, initializes it,
-// sends one request (tools/list follows every cursor) and prints the result as one JSON line. The server's stderr is
-// shown only when the call fails. It replaced `npx @modelcontextprotocol/inspector@0.4.1 --cli`, a version without a
-// CLI mode that opened its web UI and hung every plugin call until it was canceled (10/6).
-import { spawn } from 'node:child_process';
-
-const [requestJson, command, ...args] = process.argv.slice(1);
-const request = JSON.parse(requestJson);
-const child = spawn(command, args, { stdio: ['pipe', 'pipe', 'pipe'] });
-let stderr = '';
-child.stderr.on('data', (chunk) => { stderr = (stderr + chunk).slice(-8000); });
-
-function fail(message) {
-  process.stderr.write(`${message}\n${stderr}`);
-  child.kill('SIGKILL');
-  process.exit(1);
-}
-child.on('error', (error) => fail(`MCP server could not start: ${error.message}`));
-child.on('exit', (code, signal) => fail(`MCP server exited (${signal || code}) before it answered.`));
-
-const send = (message) => child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', ...message })}\n`);
-const pending = new Map();
-let nextId = 1;
-let buffer = '';
-child.stdout.setEncoding('utf8');
-child.stdout.on('data', (chunk) => {
-  buffer += chunk;
-  for (let newline = buffer.indexOf('\n'); newline >= 0; newline = buffer.indexOf('\n')) {
-    const line = buffer.slice(0, newline).trim();
-    buffer = buffer.slice(newline + 1);
-    let message;
-    // Like the MCP SDK, a line that is not JSON-RPC (a stray log) is skipped rather than ending the call.
-    try { message = JSON.parse(line); } catch { continue; }
-    if (message?.method && message.id !== undefined) {
-      send(message.method === 'ping' ? { id: message.id, result: {} }
-        : { id: message.id, error: { code: -32601, message: `${message.method} is not supported by this client.` } });
-      continue;
-    }
-    const waiter = pending.get(message?.id);
-    if (!waiter) continue;
-    pending.delete(message.id);
-    if (message.error) fail(`MCP ${waiter.method} failed: ${message.error.message || JSON.stringify(message.error)}`);
-    else waiter.resolve(message.result);
-  }
-});
-
-function call(method, params) {
-  return new Promise((resolve) => {
-    const id = nextId++;
-    pending.set(id, { method, resolve });
-    send({ id, method, ...(params === undefined ? {} : { params }) });
-  });
-}
-
-await call('initialize', { protocolVersion: '2025-06-18', capabilities: {}, clientInfo: { name: 'giz-agent', version: '1' } });
-send({ method: 'notifications/initialized' });
-let result;
-if (request.method === 'tools/list') {
-  const tools = [];
-  const cursors = new Set();
-  let cursor;
-  for (;;) {
-    const page = await call('tools/list', cursor === undefined ? undefined : { cursor });
-    if (!Array.isArray(page?.tools)) fail('MCP server returned an invalid tool catalog.');
-    tools.push(...page.tools);
-    if (page?.nextCursor == null) break;
-    if (cursors.has(page.nextCursor) || cursors.size >= 32) fail('MCP server did not finish its tool catalog.');
-    cursors.add(page.nextCursor);
-    cursor = page.nextCursor;
-  }
-  result = { tools };
-} else if (request.method === 'tools/call') {
-  result = await call('tools/call', { name: request.name, arguments: request.arguments ?? {} });
-} else {
-  fail(`Unsupported MCP request ${request.method}.`);
-}
-child.removeAllListeners('exit');
-process.stdout.write(`${JSON.stringify(result)}\n`);
-child.kill();
-process.exit(0);

package/cli/media-capture.mjs

@@ -1,321 +0,0 @@
-// media.capture inside the person's Computer: records a browser scenario at 2x device pixels, logs every pointer target,
-// typing span and wait, shortens long waits, and writes an editable HyperFrames take (camera that follows the action, a
-// redrawn cursor, click and typing feedback, speed chips). The request JSON file (its path is the one argument)
-// is deleted once read: its sign-in steps carry the person's secrets. Result JSON on stdout.
-// Runs with giz-media-node (video-tools runtime): playwright-core and HYPERFRAMES_BROWSER_PATH come from that runtime.
-import { createRequire } from 'node:module';
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import path from 'node:path';
-
-const request = JSON.parse(fs.readFileSync(process.argv[1], 'utf8'));
-fs.rmSync(process.argv[1], { force: true });
-const { chromium } = createRequire(path.join(process.cwd(), 'noop.js'))('playwright-core');
-const out = request.dir;
-const [VW, VH] = request.viewport;
-const [CW, CH] = request.canvas;
-const FPS = 30;
-const SHORTEN_AFTER = 2.5; // A wait longer than this plays at a labelled speed instead of real time.
-const SHORTENED = 1.2;
-fs.mkdirSync(path.join(out, 'frames'), { recursive: true });
-
-const browser = await chromium.launch({ executablePath: process.env.HYPERFRAMES_BROWSER_PATH, args: ['--force-device-scale-factor=2'] });
-const context = await browser.newContext({ viewport: { width: VW, height: VH }, deviceScaleFactor: 2, locale: request.locale,
-  timezoneId: request.timezone });
-const page = await context.newPage();
-const events = [];
-let t0 = 0;
-const now = () => (Date.now() - t0) / 1000;
-const round = (value) => Math.round(value * 1000) / 1000;
-const log = (event) => { if (t0) events.push({ t: round(now()), ...event }); };
-
-function locate(target) {
-  const text = String(target || '');
-  if (text.startsWith('css:')) return page.locator(text.slice(4)).first();
-  if (text.startsWith('label:')) return page.getByLabel(text.slice(6)).locator('visible=true').first();
-  if (text.startsWith('placeholder:')) return page.getByPlaceholder(text.slice(12)).locator('visible=true').first();
-  if (text.startsWith('role:')) {
-    const [, role, ...name] = text.split(':');
-    return page.getByRole(role, { name: name.join(':') || undefined }).locator('visible=true').first();
-  }
-  // Visible text: an exact match first, so "저장" does not pick "저장된 보기".
-  const exact = page.getByText(text, { exact: true }).locator('visible=true');
-  return exact.or(page.getByText(text).locator('visible=true')).first();
-}
-
-async function box(locator) {
-  const b = await locator.boundingBox().catch(() => null);
-  return b && { x: round(b.x), y: round(b.y), w: round(b.width), h: round(b.height) };
-}
-
-// A real pointer path, so hover states appear the way a person causes them.
-async function point(step) {
-  const locator = locate(step.target);
-  await locator.waitFor({ state: 'visible', timeout: step.timeoutMs ?? 15000 });
-  await locator.scrollIntoViewIfNeeded().catch(() => {});
-  const b = await box(locator);
-  if (!b) throw new Error(`${step.target} has no visible box`);
-  const x = b.x + b.w / 2, y = b.y + b.h / 2;
-  await page.mouse.move(x, y, { steps: 18 });
-  return { locator, b, x, y };
-}
-
-const label = (step) => step.label || (step.secret ? '••••' : step.target || step.value || step.action);
-
-async function run(step) {
-  const timeout = step.timeoutMs ?? 15000;
-  switch (step.action) {
-    case 'open': await page.goto(new URL(step.value, page.url() === 'about:blank' ? request.url : page.url()).href, { waitUntil: 'domcontentloaded' }); log({ action: 'open', label: label(step) }); break;
-    case 'click': case 'doubleClick': case 'rightClick': case 'hover': {
-      const { b, x, y } = await point(step);
-      log({ action: step.action, label: label(step), box: b, x, y });
-      if (step.action === 'click') await page.mouse.click(x, y);
-      if (step.action === 'doubleClick') await page.mouse.dblclick(x, y);
-      if (step.action === 'rightClick') await page.mouse.click(x, y, { button: 'right' });
-      break;
-    }
-    case 'type': case 'fill': {
-      const { locator, b, x, y } = await point(step);
-      log({ action: 'click', label: label(step), box: b, x, y });
-      await page.mouse.click(x, y);
-      if (step.action === 'fill') await locator.fill('');
-      const from = now();
-      await locator.pressSequentially(String(step.value ?? ''), { delay: 45 });
-      log({ action: 'typing', label: label(step), box: await box(locator), from: round(from) });
-      break;
-    }
-    case 'press': await page.keyboard.press(step.value); log({ action: 'press', label: step.value }); break;
-    case 'upload': {
-      const files = String(step.value || '').split('\n').filter(Boolean).map((file) => path.resolve('/home/user', file));
-      await locate(step.target).setInputFiles(files, { timeout });
-      log({ action: 'upload', label: step.label || files.map((file) => path.basename(file)).join(', ') });
-      break;
-    }
-    case 'waitFor': {
-      const from = now();
-      await locate(step.target).waitFor({ state: 'visible', timeout: step.timeoutMs ?? 180000 });
-      log({ action: 'wait', label: label(step), from: round(from) });
-      break;
-    }
-    case 'scroll': {
-      const locator = locate(step.target);
-      await locator.waitFor({ state: 'attached', timeout });
-      await locator.evaluate((element) => element.scrollIntoView({ block: 'center', behavior: 'smooth' }));
-      await page.waitForTimeout(900);
-      log({ action: 'scroll', label: label(step), box: await box(locator) });
-      break;
-    }
-    case 'focus': {
-      const locator = locate(step.target);
-      await locator.waitFor({ state: 'visible', timeout });
-      log({ action: 'focus', label: label(step), box: await box(locator) });
-      await page.waitForTimeout(step.ms ?? 1500);
-      break;
-    }
-    case 'pause': await page.waitForTimeout(step.ms ?? 1000); break;
-    case 'mark': log({ action: 'mark', label: label(step) }); break;
-    default: throw new Error(`Unknown capture action: ${step.action}`);
-  }
-}
-
-const frames = [];
-let cdp;
-let failure;
-let failedStep;
-try {
-  await page.goto(request.url, { waitUntil: 'domcontentloaded' });
-  await page.waitForLoadState('networkidle', { timeout: 15000 }).catch(() => {});
-  for (const [index, step] of request.setup.entries()) {
-    failedStep = { phase: 'setup', index };
-    await run(step);
-  }
-  // Only the scenario is recorded; signing in and preparing data stay off camera.
-  cdp = await context.newCDPSession(page);
-  cdp.on('Page.screencastFrame', async (frame) => {
-    const file = `frames/${String(frames.length).padStart(6, '0')}.jpg`;
-    fs.writeFileSync(path.join(out, file), Buffer.from(frame.data, 'base64'));
-    frames.push([frame.metadata.timestamp, file]);
-    await cdp.send('Page.screencastFrameAck', { sessionId: frame.sessionId }).catch(() => {});
-  });
-  t0 = Date.now();
-  await cdp.send('Page.startScreencast', { format: 'jpeg', quality: 92, maxWidth: VW * 2, maxHeight: VH * 2 });
-  await page.waitForTimeout(800);
-  for (const [index, step] of request.steps.entries()) {
-    failedStep = { phase: 'steps', index };
-    await run(step);
-  }
-  await page.waitForTimeout(1200);
-  failedStep = undefined;
-} catch (error) {
-  failure = String(error?.message || error).split('\n')[0];
-  await page.screenshot({ path: path.join(out, 'failed.png') }).catch(() => {});
-} finally {
-  await cdp?.send('Page.stopScreencast').catch(() => {});
-}
-const end = now();
-await context.close();
-await browser.close();
-if (failure) {
-  fs.rmSync(path.join(out, 'frames'), { recursive: true, force: true });
-  console.log(JSON.stringify({ failed: true, failure, step: failedStep, screenshot: 'failed.png' }));
-  process.exit(0);
-}
-
-// Long waits are shortened: a piecewise-linear clock maps recorded time to take time, and the frames, events and speed
-// chips all read that one map, so the cursor and camera stay on the action.
-const spans = events.filter((event) => event.action === 'wait' && event.t - event.from > SHORTEN_AFTER)
-  .map((event) => ({ from: event.from, to: event.t, rate: Math.min(16, (event.t - event.from) / SHORTENED) }));
-const clock = (t) => {
-  let shift = 0;
-  for (const span of spans) {
-    if (t <= span.from) break;
-    const inside = Math.min(t, span.to) - span.from;
-    shift += inside - inside / span.rate;
-  }
-  return round(t - shift);
-};
-const duration = clock(end);
-const start = frames[0][0];
-const list = frames.map(([stamp, file], index) => {
-  const at = clock(stamp - start);
-  const next = index + 1 < frames.length ? clock(frames[index + 1][0] - start) : duration;
-  return `file '${file}'\nduration ${Math.max(0.001, next - at).toFixed(3)}`;
-});
-fs.writeFileSync(path.join(out, 'frames.txt'), `ffconcat version 1.0\n${list.join('\n')}\nfile '${frames.at(-1)[1]}'\n`);
-// A keyframe every second: HyperFrames seeks the recording frame by frame and freezes on sparse keyframes.
-// Threads and lookahead are fixed: ffmpeg sizes them by the cores it sees, and a 2 GB Computer that saw the host's cores
-// was OOM-killed at 1.4 GB on a 2880x1620 take (prod 10/8); fixed, it stays near 0.55 GB on any core count.
-try {
-  execFileSync('ffmpeg', ['-v', 'error', '-y', '-threads', '2', '-filter_threads', '1', '-f', 'concat', '-safe', '0', '-i', path.join(out, 'frames.txt'),
-    '-vf', `fps=${FPS},scale=trunc(iw/2)*2:trunc(ih/2)*2,format=yuv420p`, '-c:v', 'libx264', '-crf', '16', '-preset', 'medium', '-g', String(FPS),
-    '-threads', '2', '-rc-lookahead', '10', '-movflags', '+faststart', path.join(out, 'screen.mp4')]);
-} catch (error) {
-  // The job reports an out-of-memory kill as such (137), not as a stack the Agent would answer by lowering quality.
-  if (error.signal === 'SIGKILL') { console.error('The screen recording encoder ran out of Computer memory.'); process.exit(137); }
-  throw error;
-}
-fs.rmSync(path.join(out, 'frames'), { recursive: true, force: true });
-fs.rmSync(path.join(out, 'frames.txt'), { force: true });
-const timeline = events.map((event) => ({ ...event, t: clock(event.t), ...(event.from !== undefined ? { from: clock(event.from) } : {}) }));
-const shortened = spans.map((span) => ({ from: clock(span.from), to: clock(span.to), rate: Math.round(span.rate * 10) / 10 }));
-fs.writeFileSync(path.join(out, 'events.json'), JSON.stringify({ viewport: [VW, VH], scale: 2, duration, shortened, events: timeline }, null, 1));
-fs.writeFileSync(path.join(out, 'take.html'), composition(timeline, shortened));
-console.log(JSON.stringify({ duration, shortened, events: timeline.map(({ t, action, label: name, from }) => ({ t, action, label: name, ...(from !== undefined ? { from } : {}) })) }));
-
-// The take composition: the screen fills the canvas, the camera frames each cluster of actions and returns to the whole
-// screen between them, and the cursor keeps its size while the camera zooms because it lives inside the camera.
-function composition(timeline, shortened) {
-  const scale = Math.min(CW / VW, CH / VH);
-  const SW = VW * scale, SH = VH * scale, SX = (CW - SW) / 2, SY = (CH - SH) / 2;
-  const maxZoom = request.camera === false ? 1 : request.maxZoom;
-  const id = request.name;
-  const tl = [];
-  const html = [];
-  const frame = (b) => {
-    if (!b || maxZoom <= 1) return { s: 1, x: 0, y: 0 };
-    const pad = 1.3;
-    const s = Math.max(1, Math.min(maxZoom, SW / (b.w * scale * pad), SH / (b.h * scale * pad)));
-    const cx = (b.x + b.w / 2) * scale, cy = (b.y + b.h / 2) * scale;
-    const x = Math.min(0, Math.max(SW - SW * s, SW / 2 - cx * s));
-    const y = Math.min(0, Math.max(SH - SH * s, SH / 2 - cy * s));
-    return { s: round(s), x: Math.round(x), y: Math.round(y) };
-  };
-  const union = (a, b) => {
-    const x = Math.min(a.x, b.x), y = Math.min(a.y, b.y);
-    return { x, y, w: Math.max(a.x + a.w, b.x + b.w) - x, h: Math.max(a.y + a.h, b.y + b.h) - y };
-  };
-  // Actions close in time and space share one framing; a page change or a shortened wait ends it.
-  const clusters = [];
-  for (const event of timeline) {
-    const last = clusters.at(-1);
-    if (event.action === 'open' || event.action === 'wait') { if (last) last.closed = true; continue; }
-    if (!event.box) continue;
-    const begins = event.from ?? event.t;
-    const ends = event.action === 'focus' ? event.t + 1.5 : event.t;
-    if (last && !last.closed && begins - last.end < 3 && frame(union(last.box, event.box)).s >= 1.2) {
-      last.box = union(last.box, event.box);
-      last.end = Math.max(last.end, ends);
-    } else clusters.push({ start: begins, end: ends, box: event.box });
-  }
-  // A framing too wide to zoom is a full-screen shot, so the camera always lands on what the next action shows.
-  const moves = [];
-  const wide = { s: 1, x: 0, y: 0 };
-  let camera = wide, free = 0;
-  for (const [index, cluster] of clusters.entries()) {
-    const framed = frame(cluster.box);
-    const target = framed.s < 1.15 ? wide : framed;
-    if (target.s !== camera.s || target.x !== camera.x || target.y !== camera.y) {
-      const at = Math.max(free, cluster.start - 0.8);
-      moves.push({ at: round(at), d: round(Math.min(0.8, Math.max(0.3, cluster.start - at))), ...target });
-      camera = target;
-    }
-    const hold = cluster.end + 1.4;
-    free = hold;
-    const next = clusters[index + 1];
-    if (camera !== wide && (!next || next.start - 0.8 - hold > 1.6)) {
-      moves.push({ at: round(Math.min(hold, duration - 0.9)), d: 0.9, ...wide });
-      camera = wide;
-      free = hold + 0.9;
-    }
-  }
-  for (const move of moves) {
-    tl.push(`tl.to("#${id}-cam",{scale:${move.s},x:${move.x},y:${move.y},duration:${move.d},ease:"power2.inOut"},${move.at});`);
-    tl.push(`tl.to("#${id}-cursor .scale",{scale:${round(1 / move.s)},duration:${move.d},ease:"power2.inOut"},${move.at});`);
-  }
-  const pointers = timeline.filter((event) => ['click', 'doubleClick', 'rightClick', 'hover'].includes(event.action) && event.x !== undefined);
-  if (pointers.length) {
-    const first = pointers[0];
-    tl.push(`tl.set("#${id}-cursor",{x:${Math.round(Math.min(VW - 40, first.x + 240) * scale)},y:${Math.round(Math.min(VH - 40, first.y + 160) * scale)}},0);`);
-    let previousAt = 0;
-    for (const event of pointers) {
-      const move = round(Math.max(0.25, Math.min(0.7, event.t - previousAt - 0.1)));
-      tl.push(`tl.to("#${id}-cursor",{x:${Math.round(event.x * scale)},y:${Math.round(event.y * scale)},duration:${move},ease:"power2.inOut"},${round(Math.max(0, event.t - move))});`);
-      if (event.action !== 'hover') {
-        tl.push(`tl.to("#${id}-cursor svg",{scale:0.82,duration:0.08,yoyo:true,repeat:1,transformOrigin:"6px 3px"},${event.t});`);
-        tl.push(`tl.fromTo("#${id}-cursor .ring",{scale:0.2,opacity:0.9},{scale:1.6,opacity:0,duration:0.5,ease:"power2.out",immediateRender:false},${event.t});`);
-      }
-      previousAt = event.t;
-    }
-  }
-  for (const [index, event] of timeline.filter((item) => item.action === 'typing' && item.box).entries()) {
-    const b = event.box;
-    html.push(`<div class="typing" id="${id}-type${index}" style="left:${Math.round(b.x * scale - 5)}px;top:${Math.round(b.y * scale - 5)}px;width:${Math.round(b.w * scale + 10)}px;height:${Math.round(b.h * scale + 10)}px"></div>`);
-    tl.push(`tl.fromTo("#${id}-type${index}",{opacity:0},{opacity:1,duration:0.2},${event.from});`);
-    tl.push(`tl.to("#${id}-type${index}",{opacity:0,duration:0.3},${round(event.t + 0.6)});`);
-  }
-  const chips = shortened.map((span, index) => {
-    tl.push(`tl.fromTo("#${id}-speed${index}",{opacity:0,scale:0.9},{opacity:1,scale:1,duration:0.2},${span.from});`);
-    tl.push(`tl.to("#${id}-speed${index}",{opacity:0,duration:0.2},${round(Math.max(span.from + 0.2, span.to - 0.2))});`);
-    return `<div class="speed" id="${id}-speed${index}">▶▶ ${span.rate}×</div>`;
-  });
-  return `<!doctype html>
-<html><head><meta charset="UTF-8">
-<script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>
-<style>
-#${id}{position:relative;width:${CW}px;height:${CH}px;overflow:hidden;background:#0b0c10;}
-#${id} .screen{position:absolute;left:${SX}px;top:${SY}px;width:${SW}px;height:${SH}px;overflow:hidden;}
-#${id}-cam{position:absolute;inset:0;transform-origin:0 0;}
-#${id}-cam video{position:absolute;inset:0;width:100%;height:100%;object-fit:fill;}
-#${id} .typing{position:absolute;border-radius:10px;border:3px solid #6463cc;box-shadow:0 0 0 6px rgba(100,99,204,.18);opacity:0;}
-#${id}-cursor{position:absolute;left:0;top:0;width:0;height:0;z-index:5;}
-#${id}-cursor .scale{position:absolute;left:-6px;top:-3px;transform-origin:6px 3px;filter:drop-shadow(0 3px 6px rgba(0,0,0,.35));}
-#${id}-cursor .ring{position:absolute;left:-26px;top:-29px;width:64px;height:64px;border-radius:50%;border:3px solid #6463cc;opacity:0;}
-#${id} .speed{position:absolute;right:${Math.round(SX + 28)}px;top:${Math.round(SY + 24)}px;z-index:6;background:rgba(12,14,30,.86);color:#fff;
-  font:600 24px/1 system-ui,sans-serif;padding:12px 20px;border-radius:999px;opacity:0;}
-</style></head>
-<body><div id="${id}" data-composition-id="${id}" data-start="0" data-width="${CW}" data-height="${CH}" data-duration="${duration}">
-<div class="screen"><div id="${id}-cam">
-<video id="${id}-screen" src="screen.mp4" muted playsinline data-start="0" data-duration="${duration}"></video>
-${html.join('\n')}
-<div id="${id}-cursor"${pointers.length ? '' : ' style="display:none"'}><div class="scale"><div class="ring"></div><svg viewBox="0 0 32 32" width="${Math.round(40 * scale / 1.2)}" height="${Math.round(40 * scale / 1.2)}"><path d="M6 3 L6 25 L11.5 19.8 L15.4 28.6 L19.2 27 L15.4 18.4 L23 18.2 Z" fill="#111" stroke="#fff" stroke-width="2" stroke-linejoin="round"/></svg></div></div>
-</div></div>
-${chips.join('\n')}
-</div>
-<script>
-const tl = gsap.timeline({ paused: true });
-${tl.join('\n')}
-window.__timelines = window.__timelines || {};
-window.__timelines["${id}"] = tl;
-</script></body></html>
-`;
-}

package/cli/update.mjs

@@ -1,150 +0,0 @@
-import { randomBytes } from 'node:crypto'
-import { mkdir, open, readFile, rename, stat, unlink, writeFile } from 'node:fs/promises'
-import os from 'node:os'
-import path from 'node:path'
-import { spawn, spawnSync } from 'node:child_process'
-import { fileURLToPath } from 'node:url'
-
-export const UPDATE_INTERVAL = 24 * 60 * 60 * 1000
-export const UPDATE_URL = 'https://registry.npmjs.org/@gizai%2fcli/latest'
-export const UPDATE_COMMAND = 'npm install -g @gizai/cli'
-const packageRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..')
-const cachePath = path.join(process.env.XDG_CACHE_HOME || path.join(os.homedir(), '.cache'), 'giz', 'cli-update.json')
-
-export function installSource(root = packageRoot) {
-  const resolved = path.resolve(root)
-  const parts = resolved.split(path.sep)
-  const nodeModules = parts.lastIndexOf('node_modules')
-  if (nodeModules < 0) return { type: 'source' }
-  const normalized = resolved.toLowerCase()
-  if (normalized.includes(`${path.sep}.pnpm${path.sep}`) || /[\\/]pnpm[\\/]global[\\/]/.test(normalized)) return { type: 'pnpm', executable: 'pnpm', args: ['add', '-g', '@gizai/cli'], command: 'pnpm add -g @gizai/cli' }
-  if (normalized.includes(`${path.sep}.bun${path.sep}`)) return { type: 'bun', executable: 'bun', args: ['add', '-g', '@gizai/cli'], command: 'bun add -g @gizai/cli' }
-  if (normalized.includes(`${path.sep}.yarn${path.sep}`) || normalized.includes(`${path.sep}yarn${path.sep}global${path.sep}`)) return { type: 'yarn', executable: 'yarn', args: ['global', 'add', '@gizai/cli'], command: 'yarn global add @gizai/cli' }
-  return { type: 'npm', executable: 'npm', args: ['install', '-g', '@gizai/cli'], command: UPDATE_COMMAND }
-}
-
-export function stableVersion(value) {
-  const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(String(value || ''))
-  if (!match) return undefined
-  const prerelease = match[4]?.split('.')
-  if (prerelease?.some((part) => !part || (/^\d+$/.test(part) && part.length > 1 && part.startsWith('0')))) return undefined
-  return { major: match[1], minor: match[2], patch: match[3], prerelease }
-}
-
-export function compareVersions(left, right) {
-  const a = stableVersion(left)
-  const b = stableVersion(right)
-  if (!a || !b) return undefined
-  for (const key of ['major', 'minor', 'patch']) {
-    if (a[key] === b[key]) continue
-    return a[key].length === b[key].length ? (a[key] < b[key] ? -1 : 1) : (a[key].length < b[key].length ? -1 : 1)
-  }
-  if (!a.prerelease && !b.prerelease) return 0
-  if (!a.prerelease) return 1
-  if (!b.prerelease) return -1
-  for (let index = 0; index < Math.max(a.prerelease.length, b.prerelease.length); index += 1) {
-    if (a.prerelease[index] === undefined) return -1
-    if (b.prerelease[index] === undefined) return 1
-    if (a.prerelease[index] === b.prerelease[index]) continue
-    const an = /^\d+$/.test(a.prerelease[index])
-    const bn = /^\d+$/.test(b.prerelease[index])
-    if (an && bn) {
-      const left = a.prerelease[index]
-      const right = b.prerelease[index]
-      return left.length === right.length ? (left < right ? -1 : 1) : (left.length < right.length ? -1 : 1)
-    }
-    if (an !== bn) return an ? -1 : 1
-    return a.prerelease[index] < b.prerelease[index] ? -1 : 1
-  }
-  return 0
-}
-
-export async function readUpdateCache(file = cachePath) {
-  try {
-    const cache = JSON.parse(await readFile(file, 'utf8'))
-    if (!Number.isFinite(cache.checkedAt) || typeof cache.latest !== 'string' || !stableVersion(cache.latest)) return undefined
-    return cache
-  } catch { return undefined }
-}
-
-async function atomicCache(file, value) {
-  await mkdir(path.dirname(file), { recursive: true, mode: 0o700 })
-  const temporary = `${file}.${process.pid}.${randomBytes(6).toString('hex')}.tmp`
-  try {
-    await writeFile(temporary, `${JSON.stringify(value)}\n`, { mode: 0o600, flag: 'wx' })
-    await rename(temporary, file)
-  } finally { await unlink(temporary).catch(() => {}) }
-}
-
-export async function latestStableVersion(fetcher = fetch, url = UPDATE_URL) {
-  const response = await fetcher(url, { signal: AbortSignal.timeout(5000), headers: { accept: 'application/json', 'npm-command': 'view' } })
-  if (!response.ok) throw new Error(`Registry HTTP ${response.status}`)
-  const version = (await response.json()).version
-  const parsed = stableVersion(version)
-  if (!parsed || parsed.prerelease) throw new Error('Registry returned no stable version')
-  return version
-}
-
-export async function checkForUpdate({ file = cachePath, fetcher = fetch, now = Date.now, url = UPDATE_URL } = {}) {
-  const lockFile = `${file}.lock`
-  let createdLock = false
-  try { await mkdir(path.dirname(file), { recursive: true, mode: 0o700 }) } catch { return undefined }
-  let lockHandle
-  try { lockHandle = await open(lockFile, 'wx', 0o600); createdLock = true }
-  catch (error) {
-    if (error.code === 'EEXIST') {
-      try { if (now() - (await stat(lockFile)).mtimeMs > 5 * 60_000) { await unlink(lockFile); return await checkForUpdate({ file, fetcher, now, url }) } } catch {}
-    }
-    return undefined
-  }
-  try {
-    const cached = await readUpdateCache(file)
-    if (cached && now() - cached.checkedAt < UPDATE_INTERVAL) return cached
-    let latest
-    try {
-      latest = await latestStableVersion(fetcher, url)
-    } catch { return cached }
-    if (!latest) return undefined
-    const result = { checkedAt: now(), latest }
-    await atomicCache(file, result)
-    return result
-  } finally {
-    await lockHandle.close().catch(() => {})
-    if (createdLock) await unlink(lockFile).catch(() => {})
-  }
-}
-
-export async function explicitUpdate({ version, source = installSource(), fetcher = fetch, run = spawnSync }) {
-  if (source.type === 'source') throw new Error('This Giz CLI is running from a source checkout; update it with your source control workflow.')
-  const latest = await latestStableVersion(fetcher)
-  const comparison = compareVersions(latest, version)
-  if (comparison === undefined) throw new Error('The installed CLI version is invalid; update it with your package manager.')
-  if (comparison <= 0) return { latest, updated: false, message: `Giz CLI ${version} is already up to date.` }
-  if (source.type !== 'npm') return { latest, updated: false, message: `Update available: ${version} → ${latest}\n${source.command}` }
-  const result = run(source.executable, source.args, { encoding: 'utf8', stdio: 'inherit' })
-  if (result.error || result.status !== 0) throw new Error(`${source.executable} update failed (${result.error?.code || result.signal || result.status}). Run: ${source.command}`)
-  return { latest, updated: true, message: `Giz CLI updated to ${latest}.` }
-}
-
-export function startBackgroundCheck({ file = cachePath, fetcherUrl = UPDATE_URL, entry = path.join(path.dirname(fileURLToPath(import.meta.url)), 'giz.mjs'), spawnProcess = spawn } = {}) {
-  try {
-    const child = spawnProcess(process.execPath, [entry, '__update-check', '--cache', file, '--registry', fetcherUrl], {
-      detached: true, stdio: 'ignore', env: { ...process.env, GIZ_UPDATE_CHECK_BACKGROUND: '1' }
-    })
-    child.on?.('error', () => {})
-    child.unref()
-    return true
-  } catch { return false }
-}
-
-export async function maybeNotify({ version, source = installSource(), mode = 'notify', env = process.env,
-  stderr = process.stderr, stdout = process.stdout, cacheFile = cachePath, now = Date.now,
-  spawnCheck = startBackgroundCheck } = {}) {
-  if (source.type === 'source' || mode === 'off' || env.GIZ_NO_UPDATE_CHECK === '1') return
-  const cache = await readUpdateCache(cacheFile)
-  if (!cache || cache.checkedAt <= 0 || now() - cache.checkedAt >= UPDATE_INTERVAL) spawnCheck({ file: cacheFile })
-  if (env.CI || !stderr.isTTY || stdout.isTTY !== true || env.GIZ_JSON === '1') return
-  if (cache && compareVersions(cache.latest, version) > 0) {
-    stderr.write(`Update available: ${version} → ${cache.latest}\n${source.command}\n`)
-  }
-}

package/mcp.json

@@ -1,6 +0,0 @@
-{
-  "$schema": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
-  "mcpServers": {
-    "giz": { "type": "streamable-http", "url": "https://www.giz.ai/api/mcp" }
-  }
-}

package/plugin.json

@@ -1,10 +0,0 @@
-{
-  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
-  "name": "giz",
-  "version": "2.0.1",
-  "description": "Run Giz models, media generation, Drive, tables, Apps and Computers from any agent: the giz skill plus the Giz MCP server.",
-  "author": { "name": "Giz", "url": "https://www.giz.ai" },
-  "homepage": "https://www.giz.ai/mcp/",
-  "license": "UNLICENSED",
-  "keywords": ["giz", "mcp", "media", "drive", "computer"]
-}