@gizai/cli 1.3.0 → 2.0.0

package/README.md

@@ -1,15 +1,33 @@
 # Giz CLI
 
-Connect once in the browser, then use live Giz text and media models, Drive, and Computer from a terminal or AI agent.
+The official command-line interface for [giz.ai](https://www.giz.ai). Run Giz text, image, video and audio models, manage Drive files, tables, Apps and Computers, and connect Claude Code, Codex and other AI agents to your Giz account, all from a terminal.
+
+[Documentation](https://www.giz.ai/mcp/) · [giz.ai](https://www.giz.ai) · [Sign up](https://www.giz.ai)
+
+## Install
+
+Requires Node.js 20.12 or later and a [giz.ai](https://www.giz.ai) account.
 
 ```bash
 npm install -g @gizai/cli
-giz auth login
-giz chat gpt-6-luna "Say hello in Korean"
+giz --version
+```
+
+Update later with `giz update` (or `npm install -g @gizai/cli`).
+
+## Quick start
+
+```bash
+giz auth login                                   # opens your browser, one-time sign-in
+giz chat gpt-6-luna "Say hello in Korean"        # chat with a text model
 giz generate image "A paper observatory at blue hour"
+giz credits                                      # check your balance
+giz --help                                       # every command
 ```
 
-Discover a model's live inputs, upload local media, and run it:
+## Run any model
+
+Discover a model's live inputs, upload local files, and run it:
 
 ```bash
 giz model list --type video-generation
@@ -19,104 +37,89 @@ giz model run ltx2-distilled \
   --upload image=./first-frame.png
 ```
 
-MCP for Claude Code and Codex (install the chosen client first):
+Media jobs run independently. Track them with `giz job get JOB` or block with `giz job wait JOB` (exit status 1 if the job failed or was cancelled). Add `--json` to any command for machine-readable output on stdout; progress goes to stderr.
+
+## Use Giz from Claude Code, Codex and other agents
+
+Register the Giz MCP server with your agent (install the client first):
 
 ```bash
 giz auth login
-giz mcp add codex
 giz mcp add claude
-giz mcp check --json
+giz mcp add codex
+giz mcp check --json        # verifies the MCP handshake and lists tool names
 ```
 
-These commands register `giz mcp serve` over stdio. It forwards the server's live
-MCP protocol and shares the CLI's rotating OAuth credentials. Tokens are not
-copied into Claude or Codex configuration. A custom `GIZ_CONFIG` path is preserved.
+This registers `giz mcp serve` over stdio. It forwards Giz's live MCP protocol and shares the CLI's credentials, so no token is copied into the client's configuration. For clients that run their own OAuth session, use `giz mcp add claude --transport http` (then sign in with `/mcp`) or `giz mcp add codex --transport http`. The remote endpoint is `https://www.giz.ai/api/mcp`; it supports OAuth discovery and scoped API keys.
 
-For clients with their own OAuth session, use `giz mcp add claude --transport http`
-and sign in through `/mcp`, or `giz mcp add codex --transport http`. The remote
-endpoint also supports OAuth discovery and scoped API keys. A manually copied
-OAuth access token expires after one hour; updating CLI credentials does not
-update a static client header.
+Install the Giz agent skill with `giz skill install`. The package root is also an [Agent Plugins](https://agent-plugins.org) 1.0 plugin (`plugin.json`, the `giz` skill and `mcp.json`), so a client that installs plugins gets the skill and the MCP server together.
 
-For a headless Claude Code check, after login and registration:
+## Drive, Computers and Apps
 
 ```bash
-claude -p 'Use model_list to list one Giz image model.' --allowedTools mcp__giz__model_list
+giz drive ls
+giz drive read /notes/todo.md
+giz computer list
+giz computer exec --deadline-ms 120000 -- ls -la    # up to 15 minutes; the remote exit code is preserved
+giz app list
 ```
 
-`giz mcp check --json` checks the MCP handshake and lists actual tool names without
-running a model. Claude's `--verbose --output-format stream-json` also shows MCP
-connection state. If registration reports an existing `giz` entry, remove that
-entry with the client's `mcp remove` command before adding the desired transport.
-The exact client failure is returned on stderr.
+App changes are explicit: pass the `revision` shown by `giz app list` as `--expected-revision REVISION` to `run`, `publish` and `delete`, and as `expectedRevision` in the `--input` of `create` and `save` (use 0 for a new App). A concurrent change is rejected by the server instead of being overwritten.
+
+Free Computers have a runtime limit; check your plan before starting long workflows. Signing in does not extend that runtime.
+
+### Inside a Giz Computer
+
+`giz` is already installed in every Giz Computer, and no login is needed: the Computer signs in as itself and can reach only its own Drive, model discovery and inference, and jobs it started. API keys, billing, organization administration, destructive operations and external writes need a separate user sign-in with `giz auth login`. `giz auth status` shows who you are.
 
-Agent Skill:
+## Plugins
 
 ```bash
-giz skill install
+giz plugin search QUERY [--origin skill|mcp]
+giz plugin install ID --query QUERY
+giz plugin list
+giz connection list       # connected apps
 ```
 
-The CLI stores rotating OAuth credentials as unencrypted JSON in
-`~/.config/giz/credentials.json` with mode `0600` (owner access only), using atomic
-writes and serialized sign-in, refresh, and sign-out. Failed token revocation is
-reported before local credentials are removed. It never stores a Giz password.
-The sign-in callback binds a fresh loopback port; use the URL printed by the
-current login. Progress goes to stderr, leaving `--json` stdout machine-readable.
+Also available: `plugin inspect`, `update`, `remove`, `enable`, `disable`, `publish` and `unpublish`.
 
-After updating from 1.0.1, run `giz auth login` again to consent to `giz.inference`.
-Refreshing an old grant cannot add this scope. `giz auth status --json` shows
-granted scopes; a missing scope error names the required permission.
+## Authentication and security
 
-`giz computer exec --deadline-ms 120000 -- COMMAND ARGS...` uses the bounded
-Computer command API (2 minutes by default, up to 15 minutes). The CLI preserves
-the remote command's exit code; `giz job wait` exits with status 1 for failed or
-cancelled jobs. JSON results remain available on stdout. Free Computers have a runtime limit; check the current
-Computer plan before starting long workflows. MCP authentication does not extend
-that runtime. Media jobs run independently and are tracked with `giz job get`.
+- `giz auth login` uses browser OAuth with a loopback callback; the CLI never sees or stores your password.
+- Credentials are stored as JSON in `~/.config/giz/credentials.json` with mode `0600` (owner only), written atomically. `GIZ_CONFIG` overrides the path. `giz auth logout` revokes the token and removes the file.
+- `giz auth status --json` shows the granted scopes; a missing scope error names the permission it needs. After updating from 1.0.1, sign in again to grant `giz.inference`.
+- Create a scoped API key with `giz api-key create "My app"` (the secret is shown once). Set `GIZ_TOKEN` only for short-lived automation.
+- An OAuth access token copied by hand expires after one hour. Prefer `giz mcp add`, which refreshes it for you.
 
-Create a scoped API key with `giz api-key create "My app"`; its secret is shown once. Set `GIZ_TOKEN` only for ephemeral automation. Run `giz --help` for chat, models, Drive, Computer, job, upload, and raw tool commands.
+## Configuration
 
-Documentation: <https://www.giz.ai/mcp/>
+| Variable | Purpose |
+| --- | --- |
+| `GIZ_TOKEN` | Use this API key or token instead of the stored login |
+| `GIZ_CONFIG` | Path of the credentials file |
+| `GIZ_NO_UPDATE_CHECK=1` | Turn off the update notice (or set `updates.mode` to `off` in `credentials.json`) |
 
-### Managed Giz Computers
+The update check is cached for up to 24 hours and prints only in interactive terminals.
 
-Giz Computers receive the same CLI source through the Region release overlay, at
-`/opt/giz/managed/apps/giz-cli`, with `/opt/giz/managed/bin/giz` first on PATH.
-No npm installation or browser login is needed inside a managed Computer:
+## Upgrading from 1.x
 
-```sh
-giz auth status
-giz drive ls
-giz model list
-```
+Version 2.0 removes `giz capability` with no alias. Skills, MCP servers and Agents now install as one plugin.
+
+| 1.x | 2.0 |
+| --- | --- |
+| `giz capability list` | `giz connection list` (connected apps), `giz plugin list` (installed plugins) |
+| `giz capability search skill\|mcp QUERY` | `giz plugin search QUERY [--origin skill\|mcp]` |
+| `giz capability install skill\|mcp ID --query QUERY` | `giz plugin install ID --query QUERY` |
+| `giz capability update\|remove ID` | `giz plugin update\|remove NAME` |
 
-The Region owns `/opt/giz/identity/identity.sock` and exchanges the Computer identity for a
-15-minute access token. For this release only, when the new socket path is absent,
-the CLI reads `/run/giz/identity.sock` to support an overlay arriving before its
-gateway update. No environment variable can override the socket path. The CLI
-caches it only in memory; it never saves a refresh
-token or API key for this identity. `giz auth status` displays
-`컴퓨터 신원으로 로그인됨 (소유자 <email>)`. A saved `giz auth login` takes priority;
-`giz auth logout` removes that user login and returns to the Computer identity.
-Shared Computers can access only their own Drive, model discovery/inference, and
-jobs started by that Computer. API key, billing, organization administration,
-destructive operations and external writes require a separate user authorization.
-The managed `giz --version` includes the Region source revision; npm installations
-continue to report the package version. Existing Computers receive overlay updates
-without recreation. The Region's normal release activation attaches identity sockets
-for existing instances, and socket replacement remains visible through the directory mount.
-
-App 변경은 `giz app list`에서 확인한 `revision`을 명시적으로 전달합니다.
-`run`, `publish`, `delete`에는 `--expected-revision REVISION`이 필요합니다.
-`create`/`save`의 `--input`에는 `id`와 `expectedRevision`을 넣습니다(새 앱은 0).
-목록을 다시 읽어 개정 번호를 자동 대체하지 않으므로, 검토 뒤 다른 변경이 생기면 서버가 충돌을 거부합니다.
-
-아래 표는 CLI 디스패처와 도구 item에서 생성합니다. 갱신 명령:
-`GIZ_UPDATE_CLI_SURFACE=1 pnpm --filter giz-app-giz test --runInBand --runTestsByPath server/external/cli-surface.spec.ts`.
-일반 CI 실행은 문서를 쓰지 않고 표의 차이를 실패로 보고합니다.
+New in 2.0: `plugin inspect`, `install --path`, `enable`, `disable`, `publish` and `unpublish`. A Giz server that supports plugins reports 2.0.0 as its minimum CLI, so 1.x prints an update warning there.
+
+## Command reference
+
+Generated from the CLI dispatcher and the Giz tool descriptors.
 
 <!-- cli-surface:start -->
-| CLI 명령 | 도구 ID | MCP 이름 | 필수 입력 | scope | Agent 발견 |
+| Command | Tool ID | MCP tool | Required input | Scope | Agent discovery |
 | --- | --- | --- | --- | --- | --- |
 | model list | model.list | model_list | - | giz.read | model.list |
 | model get | model.get | model_get | model | giz.read | model.get |
@@ -156,12 +159,26 @@ App 변경은 `giz app list`에서 확인한 `revision`을 명시적으로 전
 | app publish | app.publish | app_publish | id, expectedRevision, visibility | giz.write | app.publish |
 | app open | app.open | app_open | id | giz.read | app.open |
 | app delete | app.delete | app_delete | id, expectedRevision | giz.destructive | app.delete |
-| capability list | capability.status | capability_status | - | giz.read | capability.status |
-| capability search | capability.catalog | capability_catalog | kind, query | giz.read | capability.catalog |
-| capability install | capability.install | capability_install | id, kind, query | giz.execute | capability.install |
-| capability update | capability.manage | capability_manage | id, operation | giz.destructive | capability.manage |
-| capability remove | capability.manage | capability_manage | id, operation | giz.destructive | capability.manage |
+| plugin list | plugin.catalog | plugin_catalog | - | giz.read | plugin.catalog |
+| plugin search | plugin.catalog | plugin_catalog | - | giz.read | plugin.catalog |
+| plugin inspect | plugin.catalog | plugin_catalog | - | giz.read | plugin.catalog |
+| plugin install | plugin.install | plugin_install | - | giz.execute | plugin.install |
+| plugin update | plugin.manage | plugin_manage | operation | giz.destructive | plugin.manage |
+| plugin enable | plugin.manage | plugin_manage | operation | giz.destructive | plugin.manage |
+| plugin disable | plugin.manage | plugin_manage | operation | giz.destructive | plugin.manage |
+| plugin remove | plugin.manage | plugin_manage | operation | giz.destructive | plugin.manage |
+| plugin publish | plugin.manage | plugin_manage | operation | giz.destructive | plugin.manage |
+| plugin unpublish | plugin.manage | plugin_manage | operation | giz.destructive | plugin.manage |
+| connection list | capability.status | capability_status | - | giz.read | capability.status |
 | agent start | agent.start | agent_start | agentId, prompt | giz.execute | external only |
 | agent status | agent.status | agent_status | turnId | giz.read | agent.status |
 | agent cancel | agent.cancel | agent_cancel | turnId | giz.execute | agent.cancel |
 <!-- cli-surface:end -->
+
+## Support
+
+Questions and bug reports: [support@giz.ai](mailto:support@giz.ai) or the Support Forum at [giz.ai](https://www.giz.ai).
+
+## License
+
+Proprietary. Copyright Giz Inc. All rights reserved. Use of the service is governed by the [Terms of Use](https://www.giz.ai/terms-of-use).

package/cli/computer-identity.mjs

@@ -33,18 +33,18 @@ export async function computerIdentity(rejectedToken) {
       res.setEncoding('utf8')
       res.on('data', chunk => {
         body += chunk
-        if (body.length > 16_384) req.destroy(new Error('컴퓨터 신원 응답이 너무 큽니다.'))
+        if (body.length > 16_384) req.destroy(new Error('The Computer identity response is too large.'))
       })
       res.on('error', reject)
       res.on('end', () => {
         try {
           const value = JSON.parse(body)
-          if (res.statusCode !== 200) throw new Error(value.error_description || value.message || '컴퓨터 신원을 사용할 수 없습니다.')
+          if (res.statusCode !== 200) throw new Error(value.error_description || value.message || 'The Computer identity is unavailable.')
           const url = new URL(value.baseUrl)
           if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password ||
               url.pathname !== '/' || url.search || url.hash || !value.access_token ||
               value.token_type !== 'Bearer' || Number(value.expires_in) <= 0 || Number(value.expires_in) > 900) {
-            throw new Error('컴퓨터 신원 응답이 올바르지 않습니다.')
+            throw new Error('The Computer identity response is invalid.')
           }
           cached = { access_token: value.access_token, baseUrl: url.origin,
             expires_at: Date.now() + Number(value.expires_in) * 1000 }
@@ -56,20 +56,20 @@ export async function computerIdentity(rejectedToken) {
       if (error.code !== 'ENOENT') return reject(error)
       try {
         await lstat(socketPath)
-        reject(new Error('컴퓨터 신원 서비스에 연결할 수 없습니다. 잠시 후 다시 시도해 주세요.'))
+        reject(new Error('Cannot reach the Computer identity service. Try again shortly.'))
       } catch (lookupError) {
         if (lookupError.code !== 'ENOENT') return reject(lookupError)
         try {
           if (await managedRevision() !== undefined) {
-            reject(new Error('컴퓨터 신원을 확인할 수 없습니다. 잠시 후 다시 시도하거나 소유자에게 문의해 주세요.'))
+            reject(new Error('Cannot verify the Computer identity. Try again shortly or contact the owner.'))
           } else resolve(undefined)
         } catch (error) { reject(error) }
       }
     })
-    req.setTimeout(10_000, () => req.destroy(new Error('컴퓨터 신원 응답 시간이 초과되었습니다.')))
+    req.setTimeout(10_000, () => req.destroy(new Error('The Computer identity response timed out.')))
     req.end()
   })).catch(error => {
-    error.hint = '컴퓨터 상태를 확인하고 다시 시도해 주세요. 차단되었다면 소유자 또는 조직 관리자에게 문의해 주세요.'
+    error.hint = 'Check that the Computer is running and try again; if it is blocked, contact the owner or an organization admin.'
     throw error
   }).finally(() => { pending = undefined })
   return pending

package/cli/giz.mjs

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 import { computerIdentity, managedRevision } from './computer-identity.mjs'
+import { checkForUpdate, explicitUpdate, installSource, maybeNotify } from './update.mjs'
 import { createHash, randomBytes } from 'node:crypto'
 import { openAsBlob } from 'node:fs'
 import { mkdir, readFile, rename, unlink, writeFile } from 'node:fs/promises'
@@ -133,7 +134,7 @@ async function credentials(baseUrl, rejectedToken) {
   if (!config?.access_token) {
     const computer = await computerIdentity(rejectedToken)
     if (!computer) throw new CliError('Not authenticated.', 'Run: giz auth login')
-    if (computer.baseUrl !== baseUrl) throw new CliError('컴퓨터 신원은 다른 서버에서 사용할 수 없습니다.', '사용자 계정으로 giz auth login을 실행해 주세요.')
+    if (computer.baseUrl !== baseUrl) throw new CliError('A Computer identity cannot be used with another server.', 'Run giz auth login with your user account.')
     return computer
   }
   if (String(config.baseUrl).replace(/\/+$/, '') !== baseUrl) {
@@ -190,10 +191,10 @@ async function jsonResponse(response, baseUrl) {
     if (response.status === 404 && (payload?.code === 'EXTERNAL_TOOL_UNAVAILABLE' ||
         (new URL(response.url).pathname.startsWith('/api/tools/') && /^Unknown Giz tool: /.test(message)))) {
       const compatibility = payload?.code === 'EXTERNAL_TOOL_UNAVAILABLE'
-        ? message : '서버 버전은 확인할 수 없습니다(구버전 서버).'
+        ? message : 'The server version is unknown (older server).'
       throw new CliError(
-        `이 서버는 요청한 명령을 지원하지 않습니다. CLI ${CLI_VERSION}. ${compatibility}`,
-        `서버 주소(${baseUrl})와 지원 버전을 확인해 주세요. 지원하는 서버는 --base-url로 선택할 수 있습니다.`,
+        `This server does not support the requested command. CLI ${CLI_VERSION}. ${compatibility}`,
+        `Check the server address (${baseUrl}) and its supported version; choose a supporting server with --base-url.`,
         response.status
       )
     }
@@ -342,8 +343,9 @@ async function waitForCallback(expectedState) {
 }
 
 function openBrowser(url) {
-  const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'cmd' : 'xdg-open'
-  const args = process.platform === 'win32' ? ['/c', 'start', '', url] : [url]
+  // Not `cmd /c start`: cmd splits the URL at its first `&`, so Windows sign-in lost client_id and every later parameter.
+  const command = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'rundll32' : 'xdg-open'
+  const args = process.platform === 'win32' ? ['url.dll,FileProtocolHandler', url] : [url]
   const child = spawn(command, args, { detached: true, stdio: 'ignore' })
   child.on('error', () => {})
   child.unref()
@@ -404,11 +406,11 @@ async function applyUploads(baseUrl, input, values = []) {
 function appRevision(options) {
   const raw = options['expected-revision']
   if (raw === undefined || raw === '') {
-    throw new CliError('개정 번호가 필요합니다.', 'giz app list에서 확인한 revision을 --expected-revision으로 전달해 주세요.')
+    throw new CliError('A revision is required.', 'Pass the revision from giz app list as --expected-revision.')
   }
   const revision = Number(raw)
   if (typeof raw !== 'string' || !/^\d+$/.test(raw) || !Number.isSafeInteger(revision) || revision < 1 || revision > 9_007_199_254_740_990) {
-    throw new CliError('개정 번호는 1 이상의 안전한 정수여야 합니다.', 'giz app list에서 현재 revision을 확인해 주세요.')
+    throw new CliError('The revision must be a safe integer of 1 or more.', 'Check the current revision with giz app list.')
   }
   return revision
 }
@@ -446,6 +448,15 @@ async function serveMcp(baseUrl) {
 
 async function runCommand(baseUrl, positionals, options) {
   const [command, subcommand, ...rest] = positionals
+  if (command === '__update-check') {
+    await checkForUpdate({ file: options.cache, url: options.registry })
+    return undefined
+  }
+  if (command === 'update' && options.help === true) return { kind: 'help', value: help('update') }
+  if (command === 'update' && !subcommand) {
+    const result = await explicitUpdate({ version: CLI_VERSION, source: installSource() })
+    return { kind: 'message', value: result.message }
+  }
   if (options.version === true) {
     const revision = await managedRevision()
     return { kind: 'message', value: CLI_VERSION + (revision ? ` (region ${revision.trim()})` : '') }
@@ -649,6 +660,11 @@ async function runCommand(baseUrl, positionals, options) {
   if (command === 'table' && subcommand === 'action') {
     const view = required(rest[0], 'TABLE', 'Run: giz table action TABLE ACTION [--id ID] --input JSON')
     const action = required(rest[1], 'ACTION', 'Run: giz table get TABLE to see its actions')
+    // Namespaced table tools use their canonical external contract and table ownership checks.
+    if (action.startsWith('table.')) {
+      if (options.id !== undefined) throw new CliError('Table tools do not take --id.', 'Put row IDs in --input.')
+      return { kind: 'result', value: await invoke(baseUrl, action, { ...jsonInput(options.input), table: view }) }
+    }
     const id = options.id === undefined ? undefined : String(options.id).includes(',') ? String(options.id).split(',') : String(options.id)
     return {
       kind: 'result',
@@ -727,7 +743,7 @@ async function runCommand(baseUrl, positionals, options) {
     throw new CliError(`Unknown app command "${subcommand || ''}".`, 'Run: giz app --help')
   }
 
-  if (command === 'capability') {
+  if (command === 'connection') {
     if (subcommand === 'list') {
       return {
         kind: 'result',
@@ -736,44 +752,65 @@ async function runCommand(baseUrl, positionals, options) {
         })
       }
     }
-    if (subcommand === 'search') {
-      const kind = required(rest[0], 'KIND', 'Run: giz capability search skill|mcp QUERY')
-      const query = required(rest.slice(1).join(' '), 'QUERY', 'Run: giz capability search skill|mcp QUERY')
+    throw new CliError(`Unknown connection command "${subcommand || ''}".`, 'Run: giz connection --help')
+  }
+
+  if (command === 'plugin') {
+    const computer = options.computer ? { computer: options.computer } : {}
+    if (subcommand === 'list' || subcommand === 'search') {
+      const query = subcommand === 'search'
+        ? required(rest.join(' '), 'QUERY', 'Run: giz plugin search QUERY [--origin catalog|skill|mcp]')
+        : undefined
       return {
         kind: 'result',
-        value: await invoke(baseUrl, 'capability.catalog', {
-          kind,
-          query,
-          ...(options.limit ? { limit: Number(options.limit) } : {})
+        value: await invoke(baseUrl, 'plugin.catalog', {
+          ...(query ? { query } : { origin: 'installed' }),
+          ...(query && options.origin ? { origin: options.origin } : {}),
+          ...(options.limit ? { limit: Number(options.limit) } : {}),
+          ...computer
         })
       }
     }
+    if (subcommand === 'inspect') {
+      const drivePath = required(rest[0], 'PATH', 'Run: giz plugin inspect DRIVE_PATH')
+      return { kind: 'result', value: await invoke(baseUrl, 'plugin.catalog', { path: drivePath, ...computer }) }
+    }
     if (subcommand === 'install') {
-      const kind = required(rest[0], 'KIND', 'Run: giz capability install skill|mcp ID --query QUERY')
-      const id = required(rest[1], 'ID', 'Run: giz capability install skill|mcp ID --query QUERY')
-      const query = required(options.query, 'QUERY', 'Repeat the catalog query with --query QUERY.')
+      const source = options.path
+        ? { path: options.path }
+        : { id: required(rest[0], 'ID', 'Run: giz plugin install ID --query QUERY, or giz plugin install --path DRIVE_PATH') }
       return {
         kind: 'result',
-        value: await invoke(baseUrl, 'capability.install', {
-          kind,
-          id,
-          query,
-          ...(options.computer ? { computer: options.computer } : {})
+        value: await invoke(baseUrl, 'plugin.install', {
+          ...source,
+          ...(options.query ? { query: options.query } : {}),
+          ...computer
         })
       }
     }
-    if (subcommand === 'update' || subcommand === 'remove') {
-      const id = required(rest[0], 'ID', `Run: giz capability ${subcommand} ID`)
+    if (['update', 'enable', 'disable', 'remove'].includes(subcommand)) {
+      const name = required(rest[0], 'NAME', `Run: giz plugin ${subcommand} NAME`)
+      return { kind: 'result', value: await invoke(baseUrl, 'plugin.manage', { operation: subcommand, name, ...computer }) }
+    }
+    if (subcommand === 'publish') {
+      const drivePath = required(rest[0], 'PATH', 'Run: giz plugin publish DRIVE_PATH --visibility organization|public')
+      const visibility = required(options.visibility, 'VISIBILITY', 'Add --visibility organization|public.')
       return {
         kind: 'result',
-        value: await invoke(baseUrl, 'capability.manage', {
-          id,
-          operation: subcommand,
-          ...(options.computer ? { computer: options.computer } : {})
+        value: await invoke(baseUrl, 'plugin.manage', {
+          operation: 'publish',
+          path: drivePath,
+          visibility,
+          ...(options.organization ? { organizationId: options.organization } : {}),
+          ...computer
         })
       }
     }
-    throw new CliError(`Unknown capability command "${subcommand || ''}".`, 'Run: giz capability --help')
+    if (subcommand === 'unpublish') {
+      const releaseId = required(rest[0], 'RELEASE', 'Run: giz plugin unpublish RELEASE')
+      return { kind: 'result', value: await invoke(baseUrl, 'plugin.manage', { operation: 'unpublish', releaseId }) }
+    }
+    throw new CliError(`Unknown plugin command "${subcommand || ''}".`, 'Run: giz plugin --help')
   }
 
   if (command === 'agent') {
@@ -864,7 +901,7 @@ function print(kind, value, json, output = process.stdout) {
     return
   }
   if (kind === 'auth' && value.identity?.type === 'computer') {
-    output.write(`컴퓨터 신원으로 로그인됨 (소유자 ${value.email || value.name})\n`)
+    output.write(`Signed in as a Computer identity (owner ${value.email || value.name})\n`)
     return
   }
   if (kind === 'models') {
@@ -955,7 +992,7 @@ Generation returns a job immediately; use giz job wait JOB_ID for its result.`
 
 TABLE is a table's Drive path (for example Sales/Customers.view.ts) or a business object name from giz table list
 (for example task, issue, requirement). giz table get shows its fields, the row changes it accepts (writes) and its
-actions; an object without a write changes only through its actions. Use --org to work in an organization.
+actions. Namespaced table actions (such as table.updateSchema) use the table tool contract; an object without a write changes only through its actions. Use --org to work in an organization.
 read input:  {"select":["name"],"filters":[{"field":"status","operator":"eq","value":"open"}],"limit":50}
 write input: {"create":[{"name":"Acme"}],"update":[{"id":"ROW_ID","status":"done"}],"remove":["ROW_ID"]}
 One write is one change people can undo in the table. At most 200 rows per write.`
@@ -970,11 +1007,19 @@ One write is one change people can undo in the table. At most 200 rows per write
   giz app publish APP_ID private|workspace|public --expected-revision REVISION [--computer COMPUTER]
   giz app open APP_ID [--computer COMPUTER]
   giz app delete APP_ID --expected-revision REVISION [--computer COMPUTER]`
-  if (command === 'capability') return `Usage
-  giz capability list [--computer COMPUTER]
-  giz capability search skill|mcp QUERY
-  giz capability install skill|mcp ID --query QUERY [--computer COMPUTER]
-  giz capability update|remove ID [--computer COMPUTER]`
+  if (command === 'plugin') return `Usage
+  giz plugin list [--computer COMPUTER]
+  giz plugin search QUERY [--origin catalog|skill|mcp] [--limit N]
+  giz plugin inspect DRIVE_PATH
+  giz plugin install ID --query QUERY [--computer COMPUTER]
+  giz plugin install --path DRIVE_PATH [--computer COMPUTER]
+  giz plugin update|enable|disable|remove NAME [--computer COMPUTER]
+  giz plugin publish DRIVE_PATH --visibility organization|public [--organization ORG]
+  giz plugin unpublish RELEASE
+
+A plugin (Agent Plugins 1.0) bundles skills, MCP servers and Agents; it is what you install, turn off and share.`
+  if (command === 'connection') return `Usage
+  giz connection list [--computer COMPUTER]`
   if (command === 'agent') return `Usage
   giz agent start [--computer COMPUTER] --input JSON
   giz agent status TURN [--wait]
@@ -987,6 +1032,7 @@ One write is one change people can undo in the table. At most 200 rows per write
 
 stdio (default) shares giz auth login and refreshes tokens automatically.
 http uses the client's own OAuth login. Install the chosen client first.`
+  if (command === 'update') return `Usage\n  giz update\n\nUpdates @gizai/cli with its owning package manager.`
   if (command === 'auth') return `Usage
   giz auth login [--device]
   giz auth status
@@ -995,6 +1041,7 @@ http uses the client's own OAuth login. Install the chosen client first.`
 
 Usage
   giz auth login [--device]
+  giz update
   giz api-key list|create|revoke
   giz chat MODEL "your prompt"
   giz model list [--type TYPE] [--search TEXT]
@@ -1009,7 +1056,8 @@ Usage
   giz upload LOCAL_PATH
   giz computer list|get|start|stop|exec
   giz app list|create|save|run|publish|open|delete
-  giz capability list|search|install|update|remove
+  giz plugin list|search|inspect|install|update|enable|disable|remove|publish|unpublish
+  giz connection list
   giz agent start|status|cancel
   giz engine run claude "instruction" [--dir path]
   giz mcp url|serve|check|add
@@ -1029,9 +1077,17 @@ Docs: https://www.giz.ai/mcp/`
 
 async function main() {
   const { positionals, options } = parse(process.argv.slice(2))
+  if (positionals[0] === '__update-check') {
+    await runCommand('', positionals, options)
+    return
+  }
+  const source = installSource()
   const saved = await readConfig()
+  const updateMode = ['notify', 'off'].includes(saved?.updates?.mode) ? saved.updates.mode : 'notify'
+  void maybeNotify({ version: CLI_VERSION, source, mode: updateMode, env: { ...process.env, GIZ_JSON: options.json === true ? '1' : process.env.GIZ_JSON } }).catch(() => {})
   const requiresAuth = positionals.length && !options.help && !options.version &&
-    !(positionals[0] === 'auth' && ['login', 'logout'].includes(positionals[1]))
+    !(positionals[0] === 'auth' && ['login', 'logout'].includes(positionals[1])) &&
+    !['update', '__update-check'].includes(positionals[0])
   const computer = requiresAuth && !process.env.GIZ_TOKEN && !saved?.access_token ? await computerIdentity() : undefined
   const baseUrl = String(options['base-url'] || process.env.GIZ_URL || saved?.baseUrl || computer?.baseUrl || DEFAULT_URL).replace(/\/+$/, '')
   if (typeof options.org === 'string') process.env.GIZ_ORGANIZATION = options.org

package/cli/mcp-stdio-client.mjs

@@ -0,0 +1,81 @@
+// 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

@@ -0,0 +1,321 @@
+// 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

@@ -0,0 +1,150 @@
+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

@@ -0,0 +1,6 @@
+{
+  "$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/package.json

@@ -1,7 +1,31 @@
 {
   "name": "@gizai/cli",
-  "version": "1.3.0",
-  "description": "Giz CLI, MCP installer, OpenAI-compatible models, Drive, and Computer",
+  "version": "2.0.0",
+  "description": "The official command-line interface for giz.ai: run AI models, Drive, Computers and Apps, and connect Claude Code, Codex and other agents over MCP.",
+  "keywords": [
+    "giz",
+    "giz.ai",
+    "cli",
+    "mcp",
+    "model-context-protocol",
+    "ai",
+    "llm",
+    "agent",
+    "claude-code",
+    "codex",
+    "image-generation",
+    "video-generation"
+  ],
+  "homepage": "https://www.giz.ai/mcp/",
+  "bugs": {
+    "email": "support@giz.ai",
+    "url": "https://www.giz.ai/mcp/"
+  },
+  "author": {
+    "name": "Giz Inc.",
+    "url": "https://www.giz.ai"
+  },
+  "license": "UNLICENSED",
   "type": "module",
   "bin": {
     "giz": "cli/giz.mjs"
@@ -9,6 +33,8 @@
   "files": [
     "cli",
     "skills",
+    "plugin.json",
+    "mcp.json",
     "README.md"
   ],
   "engines": {
@@ -18,17 +44,6 @@
     "@modelcontextprotocol/sdk": "1.29.0",
     "proper-lockfile": "4.1.2"
   },
-  "keywords": [
-    "giz",
-    "mcp",
-    "ai",
-    "image",
-    "video",
-    "audio",
-    "agent"
-  ],
-  "license": "UNLICENSED",
-  "homepage": "https://www.giz.ai/mcp/",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/GizAI/giz.git",

package/plugin.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "name": "giz",
+  "version": "2.0.0",
+  "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"]
+}

package/skills/giz/SKILL.md

@@ -64,17 +64,17 @@ Pass `--json` for machine output. Use `GIZ_TOKEN` only in ephemeral automation.
 
 Read [references/operations.md](references/operations.md) when MCP discovery is unavailable or when choosing between Drive and Computer tools.
 
-App 변경은 `giz app list`에서 확인한 `revision`을 명시적으로 전달합니다.
-`run`, `publish`, `delete`에는 `--expected-revision REVISION`이 필요합니다.
-`create`/`save`의 `--input`에는 `id`와 `expectedRevision`을 넣습니다(새 앱은 0).
-목록을 다시 읽어 개정 번호를 자동 대체하지 않으므로, 검토 뒤 다른 변경이 생기면 서버가 충돌을 거부합니다.
+App changes pass the `revision` read from `giz app list` explicitly.
+`run`, `publish` and `delete` require `--expected-revision REVISION`.
+The `--input` of `create` and `save` carries `id` and `expectedRevision` (0 for a new App).
+The CLI never re-reads the list to substitute a revision, so the server rejects the call if another change landed after your review.
 
-아래 표는 CLI 디스패처와 도구 item에서 생성합니다. 갱신 명령:
+The table below is generated from the CLI dispatcher and the tool descriptors. To refresh it, run:
 `GIZ_UPDATE_CLI_SURFACE=1 pnpm --filter giz-app-giz test --runInBand --runTestsByPath server/external/cli-surface.spec.ts`.
-일반 CI 실행은 문서를 쓰지 않고 표의 차이를 실패로 보고합니다.
+A normal CI run does not write the document; it fails on any difference in the table.
 
 <!-- cli-surface:start -->
-| CLI 명령 | 도구 ID | MCP 이름 | 필수 입력 | scope | Agent 발견 |
+| Command | Tool ID | MCP tool | Required input | Scope | Agent discovery |
 | --- | --- | --- | --- | --- | --- |
 | model list | model.list | model_list | - | giz.read | model.list |
 | model get | model.get | model_get | model | giz.read | model.get |
@@ -114,11 +114,17 @@ App 변경은 `giz app list`에서 확인한 `revision`을 명시적으로 전
 | app publish | app.publish | app_publish | id, expectedRevision, visibility | giz.write | app.publish |
 | app open | app.open | app_open | id | giz.read | app.open |
 | app delete | app.delete | app_delete | id, expectedRevision | giz.destructive | app.delete |
-| capability list | capability.status | capability_status | - | giz.read | capability.status |
-| capability search | capability.catalog | capability_catalog | kind, query | giz.read | capability.catalog |
-| capability install | capability.install | capability_install | id, kind, query | giz.execute | capability.install |
-| capability update | capability.manage | capability_manage | id, operation | giz.destructive | capability.manage |
-| capability remove | capability.manage | capability_manage | id, operation | giz.destructive | capability.manage |
+| plugin list | plugin.catalog | plugin_catalog | - | giz.read | plugin.catalog |
+| plugin search | plugin.catalog | plugin_catalog | - | giz.read | plugin.catalog |
+| plugin inspect | plugin.catalog | plugin_catalog | - | giz.read | plugin.catalog |
+| plugin install | plugin.install | plugin_install | - | giz.execute | plugin.install |
+| plugin update | plugin.manage | plugin_manage | operation | giz.destructive | plugin.manage |
+| plugin enable | plugin.manage | plugin_manage | operation | giz.destructive | plugin.manage |
+| plugin disable | plugin.manage | plugin_manage | operation | giz.destructive | plugin.manage |
+| plugin remove | plugin.manage | plugin_manage | operation | giz.destructive | plugin.manage |
+| plugin publish | plugin.manage | plugin_manage | operation | giz.destructive | plugin.manage |
+| plugin unpublish | plugin.manage | plugin_manage | operation | giz.destructive | plugin.manage |
+| connection list | capability.status | capability_status | - | giz.read | capability.status |
 | agent start | agent.start | agent_start | agentId, prompt | giz.execute | external only |
 | agent status | agent.status | agent_status | turnId | giz.read | agent.status |
 | agent cancel | agent.cancel | agent_cancel | turnId | giz.execute | agent.cancel |

package/skills/giz/references/operations.md

@@ -14,6 +14,6 @@
 | Discover and control Computers | `computer_list`, `computer_start`, `computer_stop` |
 | Run a Computer command | `giz_computer_exec` |
 | Find, inspect, or interact with an existing terminal | `terminal_list`, `terminal_observe`, `terminal_send` |
-| Inspect or transform media | `media_probe`, `media_process` |
+| Record, inspect or transform media | `media_capture`, `media_probe`, `media_process` |
 
 Always prefer the live `tools/list` result over this map. Streamable HTTP MCP is `/api/mcp`; ChatGPT OpenAPI is `/api/openapi.json`; the authenticated HTTP manifest is `/api/tools`. `giz_computer_exec` accepts an exact Computer name, slug, or ID as `computer`, argv `command`, optional `stdin`, `cwd`, and `deadlineMs`; do not send `timeoutMs`, `yieldMs`, `sessionId`, or shell command strings. Omit `computer` for the default Computer and use `computer_list` only when the target is unknown or ambiguous.