@gizai/cli 2.1.2 → 2.2.1

package/README.md

@@ -1,15 +1,196 @@
-# @gizai/cli
+# Giz CLI
 
-GizStack 0.1.0-preview.20261023.8 from npm: natively compiled TypeScript, with the whole stack built in: a modern web framework and server, OLTP and OLAP SQL (PostgreSQL- and Oracle-compatible), vector search, key-value, distributed POSIX and S3 storage, GPU tensors, and local LLM, image and video generation. Docs: https://gizstack.com/docs/start
+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.
 
-```sh
+[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
-npx @gizai/cli --version
-bunx @gizai/cli --version
+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
+```
+
+## Gizlang
+
+The same `giz` runs [Gizlang](https://gizstack.com/docs) and GizStack. The native toolchain is not part of this
+package: the first Gizlang command installs it for your OS into `~/.giz` (`GIZ_INSTALL`), with its size shown first.
+
+```bash
+giz init hello && cd hello    # installs the toolchain once, then creates the project
+giz run main.giz
+giz deploy                    # signs in with the same giz auth login
+gizdb serve --dir ~/gizdb-data --port 5432
+```
+
+## Run any model
+
+Discover a model's live inputs, upload local files, and run it:
+
+```bash
+giz model list --type video-generation
+giz model get ltx2-distilled
+giz model run ltx2-distilled \
+  --input '{"prompt":"A slow camera push through morning fog"}' \
+  --upload image=./first-frame.png
+```
+
+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 claude
+giz mcp add codex
+giz mcp check --json        # verifies the MCP handshake and lists tool names
 ```
 
-One package serves every platform and runs no install script. The first run installs GizStack into `~/.giz`
-(`GIZ_INSTALL`): `bin/install.sh` finds your platform, downloads its installer from the content address
-written in the script, checks its SHA-256, and the installer checks the release signature and every file.
+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.
+
+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.
+
+## Drive, Computers and Apps
+
+```bash
+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
+```
+
+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.
+
+## Plugins
+
+```bash
+giz plugin search QUERY [--origin skill|mcp]
+giz plugin install ID --query QUERY
+giz plugin list
+giz connection list       # connected apps
+```
+
+Also available: `plugin inspect`, `update`, `remove`, `enable`, `disable`, `publish` and `unpublish`.
+
+## Authentication and security
+
+- `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.
+
+## Configuration
+
+| 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`) |
+
+The update check is cached for up to 24 hours and prints only in interactive terminals.
+
+## Upgrading from 1.x
+
+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` |
+
+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 -->
+| 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 |
+| model run | model.run | model_run | model, input | giz.inference | model.run |
+| generate image | generateImage | generateImage | prompt | giz.write | generateImage |
+| generate video | generateVideo | generateVideo | prompt | giz.write | generateVideo |
+| generate music | generateMusic | generateMusic | prompt | giz.write | generateMusic |
+| generate talking-head | generateTalkingHead | generateTalkingHead | prompt, references | giz.write | generateTalkingHead |
+| generate audio | generateAudio | generateAudio | purpose | giz.write | generateAudio |
+| job list | job.list | job_list | - | giz.read | server job |
+| 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 |
+| drive read | drive.readFile | drive_readFile | path | giz.read | drive.readFile |
+| drive write | drive.writeFile | drive_writeFile | path, content | giz.write | drive.writeFile |
+| drive mkdir | drive.makeDirectory | drive_makeDirectory | path | giz.write | drive.makeDirectory |
+| drive move | drive.movePath | drive_movePath | from, to | giz.write | drive.movePath |
+| drive delete | drive.deletePath | drive_deletePath | path | giz.destructive | drive.deletePath |
+| table list | workspace.objects | workspace_objects | - | giz.read | workspace.objects |
+| table get | workspace.objects | workspace_objects | - | giz.read | workspace.objects |
+| table read | table.readRows | table_readRows | table | giz.read | table.readRows |
+| table write | table.writeRows | table_writeRows | table | giz.write | table.writeRows |
+| table action | workspace.executeAction | workspace_executeAction | view, action | giz.execute | workspace.executeAction |
+| computer list | computer.list | computer_list | - | giz.read | computer.list |
+| computer get | computer.get | computer_get | - | giz.read | external only |
+| computer start | computer.start | computer_start | - | giz.execute | external only |
+| computer stop | computer.stop | computer_stop | - | giz.destructive | external only |
+| computer exec | computer.exec | giz_computer_exec | - | giz.execute | computer.exec |
+| app list | app.list | app_list | - | giz.read | app.list |
+| app create | app.save | app_save | id, expectedRevision | giz.execute | app.save |
+| app save | app.save | app_save | id, expectedRevision | giz.execute | app.save |
+| app run | app.run | app_run | id, expectedRevision | giz.execute | app.run |
+| 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 |
+| 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
 
-GizStack is open source under the MIT license: https://github.com/gizai/gizlang
+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/codex-relay.mjs

@@ -0,0 +1,46 @@
+// Runs ONLY inside the user's Computer. stdout is the authenticated gateway wire,
+// never credentials or provider error bodies. No listener or separate credential store.
+import { readFile } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { join } from 'node:path'
+import { execFileSync } from 'node:child_process'
+
+const emit = value => process.stdout.write(JSON.stringify(value) + '\n')
+try {
+  const auth = JSON.parse(await readFile(join(process.env.CODEX_HOME || join(homedir(), '.codex'), 'auth.json'), 'utf8'))
+  const token = auth.tokens?.access_token
+  const account = auth.tokens?.account_id
+  if (auth.OPENAI_API_KEY || !token || !account) {
+    emit({ status: 401 }); process.exitCode = 1
+  } else {
+    const headers = { authorization: `Bearer ${token}`, 'chatgpt-account-id': account, 'content-type': 'application/json', originator: 'codex_cli_rs' }
+    const mode = process.argv[2]
+    if (mode === 'models') {
+      const version = execFileSync('codex', ['--version'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim().split(' ').at(-1)
+      const response = await fetch(`https://chatgpt.com/backend-api/codex/models?client_version=${encodeURIComponent(version)}`, { headers, signal: AbortSignal.timeout(30000) })
+      if (!response.ok) emit({ status: response.status })
+      else {
+        const payload = await response.json()
+        emit({ status: 200, models: (payload.models || []).filter(model => model.visibility !== 'hide').map(model => ({ id: model.slug, label: model.display_name || model.slug })).filter(model => typeof model.id === 'string' && model.id.length <= 256) })
+      }
+    } else if (mode === 'responses') {
+      let input = ''
+      for await (const chunk of process.stdin) input += chunk
+      const body = JSON.parse(input)
+      body.store = false
+      body.stream = true
+      body.instructions ??= ''
+      delete body.max_output_tokens
+      delete body.temperature
+      delete body.top_p
+      const response = await fetch('https://chatgpt.com/backend-api/codex/responses', { method: 'POST', headers, body: JSON.stringify(body), signal: AbortSignal.timeout(300000) })
+      emit({ status: response.status })
+      if (response.ok) {
+        for await (const chunk of response.body) emit({ chunk: Buffer.from(chunk).toString('base64') })
+        emit({ done: true })
+      }
+    } else emit({ status: 400 })
+  }
+} catch {
+  emit({ status: 503 }); process.exitCode = 1
+}

package/cli/computer-identity.mjs

@@ -0,0 +1,76 @@
+import { lstat, readFile } from 'node:fs/promises'
+import { request } from 'node:http'
+
+export const IDENTITY_SOCKET = '/opt/giz/identity/identity.sock'
+
+// One-release bridge: the managed CLI overlay can arrive before the Region gateway migration.
+export async function resolveIdentitySocket() {
+  try {
+    await lstat(IDENTITY_SOCKET)
+    return IDENTITY_SOCKET
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error
+    return '/run/giz/identity.sock'
+  }
+}
+let cached
+let pending
+
+// The release overlay owns this stamp; outside npm installations do not have it.
+export async function managedRevision() {
+  return readFile(new URL('../REVISION', import.meta.url), 'utf8').catch(error => {
+    if (error.code !== 'ENOENT') throw error
+  })
+}
+
+// The CLI never accepts a socket path from options, environment, or request data.
+export async function computerIdentity(rejectedToken) {
+  if (cached?.access_token !== rejectedToken && cached?.expires_at > Date.now() + 60_000) return cached
+  pending ??= resolveIdentitySocket().then(socketPath => new Promise((resolve, reject) => {
+    const req = request({ socketPath, path: '/token', method: 'POST',
+      headers: { 'content-length': '0' } }, res => {
+      let body = ''
+      res.setEncoding('utf8')
+      res.on('data', chunk => {
+        body += chunk
+        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 || '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('The Computer identity response is invalid.')
+          }
+          cached = { access_token: value.access_token, baseUrl: url.origin,
+            expires_at: Date.now() + Number(value.expires_in) * 1000 }
+          resolve(cached)
+        } catch (error) { reject(error) }
+      })
+    })
+    req.on('error', async error => {
+      if (error.code !== 'ENOENT') return reject(error)
+      try {
+        await lstat(socketPath)
+        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('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('The Computer identity response timed out.')))
+    req.end()
+  })).catch(error => {
+    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/engine.mjs

@@ -0,0 +1,58 @@
+import { spawn, execFileSync } from 'node:child_process'
+import { mkdir } from 'node:fs/promises'
+import { randomUUID } from 'node:crypto'
+import path from 'node:path'
+
+/** Local Computer execution: official binary, existing permissions, isolated reviewable worktree. */
+export async function runEngine(engine, instruction, directory = process.cwd(), progress = () => {}) {
+  if (engine !== 'claude' || typeof instruction !== 'string' || !instruction.trim()) throw new Error('Run: giz engine run claude "instruction" [--dir path]')
+  const git = (args, cwd = directory) => execFileSync('git', args, { cwd, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], maxBuffer: 8 * 1024 * 1024 })
+  const env = { ...process.env }
+  for (const key of ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'ANTHROPIC_BASE_URL', 'CLAUDE_CODE_USE_BEDROCK', 'CLAUDE_CODE_USE_VERTEX', 'CLAUDE_CODE_USE_FOUNDRY']) delete env[key]
+  const status = spawn('claude', ['auth', 'status'], { env, stdio: ['ignore', 'pipe', 'ignore'] })
+  let login = ''
+  status.stdout.on('data', chunk => { login += chunk })
+  await new Promise((resolve, reject) => { status.once('error', reject); status.once('close', code => code === 0 ? resolve() : reject(new Error('Log in to Claude Code in Connections.'))) })
+  const account = JSON.parse(login)
+  if (!account.loggedIn || account.authMethod !== 'claude.ai') throw new Error('A Claude subscription login is required.')
+  const root = git(['rev-parse', '--show-toplevel']).trim()
+  const common = path.resolve(root, git(['rev-parse', '--git-common-dir']).trim())
+  const worktree = path.join(common, 'giz-engine-worktrees', randomUUID())
+  await mkdir(path.dirname(worktree), { recursive: true })
+  git(['worktree', 'add', '--detach', worktree, 'HEAD'])
+  progress({ status: 'running', engine, worktree })
+  const child = spawn('claude', ['-p', instruction, '--output-format', 'stream-json', '--verbose', '--permission-mode', 'acceptEdits'],
+    { cwd: worktree, env, detached: true, stdio: ['ignore', 'pipe', 'pipe'] })
+  let output = '', summary = '', stopped = false
+  const stop = () => { stopped = true; try { process.kill(-child.pid, 'SIGTERM') } catch {} }
+  process.once('SIGTERM', stop); process.once('SIGINT', stop)
+  child.stdout.on('data', chunk => {
+    output += chunk
+    let newline
+    while ((newline = output.indexOf('\n')) >= 0) {
+      const line = output.slice(0, newline); output = output.slice(newline + 1)
+      try {
+        const event = JSON.parse(line)
+        if (event.type === 'result') summary = String(event.result || '')
+        // Do not pass raw tool inputs, prompts or authorization data into the task card.
+        progress({ status: 'running', event: event.type, engine, worktree })
+      } catch {}
+    }
+  })
+  child.stderr.resume()
+  let exitCode
+  try {
+    exitCode = await new Promise((resolve, reject) => { child.once('error', reject); child.once('close', code => resolve(code)) })
+  } finally { process.removeListener('SIGTERM', stop); process.removeListener('SIGINT', stop) }
+  const tracked = git(['diff', '--name-only', 'HEAD'], worktree).trim().split('\n').filter(Boolean)
+  const created = git(['ls-files', '--others', '--exclude-standard'], worktree).trim().split('\n').filter(Boolean)
+  let diff = git(['diff', '--binary', 'HEAD'], worktree)
+  for (const file of created) {
+    try { diff += git(['diff', '--no-index', '--binary', '--', '/dev/null', file], worktree) }
+    catch (error) {
+      if (error.status !== 1) throw error
+      diff += String(error.stdout)
+    }
+  }
+  return { status: stopped ? 'canceled' : exitCode === 0 ? 'completed' : 'failed', engine, exitCode, worktree, files: [...new Set([...tracked, ...created])], diff, summary }
+}