@gizai/cli 1.2.1 → 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-5-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 |
@@ -130,6 +133,7 @@ App 변경은 `giz app list`에서 확인한 `revision`을 명시적으로 전
 | job get | job.get | job_get | job | giz.read | server job |
 | job wait | job.get | job_get | job | giz.read | server job |
 | job cancel | job.cancel | job_cancel | job | giz.destructive | server job |
+| credits | account.credits | account_credits | - | giz.read | account.credits |
 | drive ls | drive.list | drive_list | - | giz.read | drive.list |
 | drive list | drive.list | drive_list | - | giz.read | drive.list |
 | drive search | drive.search | drive_search | query | giz.read | drive.search |
@@ -155,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,11 +448,26 @@ 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()})` : '') }
   }
-  if (!command || command === 'help' || options.help === true) return { kind: 'help', value: help(command) }
+  if (!command || command === 'help' || options.help === true) {
+    // A script that asks for help on a command that does not exist must fail, not read the overview as success.
+    if (command && command !== 'help' && !help().split('\n').some((line) => line.trim().split(' ')[1] === command && line.startsWith('  giz '))) {
+      throw new CliError(`Unknown command "${command}".`, 'Run: giz --help')
+    }
+    return { kind: 'help', value: help(command) }
+  }
   if (command === 'engine' && subcommand === 'run') {
     if (rest[0] !== 'claude') throw new CliError('Only Claude Code is an engine connection.')
     await api(baseUrl, '/api/external/engine/claude/authorization')
@@ -505,6 +522,11 @@ async function runCommand(baseUrl, positionals, options) {
     }
   }
 
+  if (command === 'credits') {
+    // Batch scripts read the balance before paid work instead of learning it from a refusal (MCP-TOOL-SCHEMA-LIMITS).
+    if (subcommand) throw new CliError(`Unknown command "credits ${subcommand}".`, 'Run: giz credits')
+    return { kind: 'result', value: await invoke(baseUrl, 'account.credits', {}) }
+  }
   if (command === 'model' && subcommand === 'list') {
     return {
       kind: 'models',
@@ -638,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',
@@ -716,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',
@@ -725,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') {
@@ -853,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') {
@@ -897,6 +945,11 @@ Progress and the final diff, files and summary are returned. Interrupting stops
   giz api-key revoke KEY_ID
 
 The secret is shown only when the key is created.`
+  if (command === 'credits') return `Usage
+  giz credits
+
+Prints your remaining credit (purchased and plan), when plan credit resets, and this month's spend and charges.
+In a workspace it prints the workspace's monthly budget. Read it before paid batch work.`
   if (command === 'chat') return `Usage
   giz chat MODEL "your prompt"
   giz chat MODEL --input '{"messages":[{"role":"user","content":"Hello"}]}'`
@@ -939,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.`
@@ -954,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]
@@ -971,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
@@ -979,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]
@@ -987,12 +1050,14 @@ Usage
   giz generate image|video|music|talking-head "PROMPT" [--model MODEL]
   giz generate audio --input JSON [--model MODEL]
   giz job list|get|wait|cancel [JOB]
+  giz credits
   giz drive ls|list|search|read|write|mkdir|move|delete
   giz table list|get|read|write|action
   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
@@ -1012,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