@gizai/cli 1.0.1 → 1.2.1

package/README.md

@@ -1,10 +1,11 @@
 # Giz CLI
 
-Connect once in the browser, then use every live Giz non-LLM model, Drive, and Computer from a terminal or AI agent.
+Connect once in the browser, then use live Giz text and media models, Drive, and Computer from a terminal or AI agent.
 
 ```bash
 npm install -g @gizai/cli
 giz auth login
+giz chat gpt-5-6-luna "Say hello in Korean"
 giz generate image "A paper observatory at blue hour"
 ```
 
@@ -18,20 +19,148 @@ giz model run ltx2-distilled \
   --upload image=./first-frame.png
 ```
 
-Remote MCP:
+MCP for Claude Code and Codex (install the chosen client first):
 
 ```bash
+giz auth login
 giz mcp add codex
 giz mcp add claude
+giz mcp check --json
+```
+
+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.
+
+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.
+
+For a headless Claude Code check, after login and registration:
+
+```bash
+claude -p 'Use model_list to list one Giz image model.' --allowedTools mcp__giz__model_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.
+
 Agent Skill:
 
 ```bash
 giz skill install
 ```
 
-The CLI stores rotating OAuth credentials in `~/.config/giz/credentials.json` with mode `0600`. It never asks for or stores a Giz password.
-Set `GIZ_TOKEN` only for ephemeral automation. Run `giz --help` for Drive, Computer, job, upload, and raw tool commands.
+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.
+
+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.
+
+`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`.
+
+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.
 
 Documentation: <https://www.giz.ai/mcp/>
+
+### Managed Giz Computers
+
+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:
+
+```sh
+giz auth status
+giz drive ls
+giz model list
+```
+
+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 실행은 문서를 쓰지 않고 표의 차이를 실패로 보고합니다.
+
+<!-- cli-surface:start -->
+| CLI 명령 | 도구 ID | MCP 이름 | 필수 입력 | scope | Agent 발견 |
+| --- | --- | --- | --- | --- | --- |
+| 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 |
+| 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 |
+| 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 |
+| 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 -->

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('컴퓨터 신원 응답이 너무 큽니다.'))
+      })
+      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 || '컴퓨터 신원을 사용할 수 없습니다.')
+          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('컴퓨터 신원 응답이 올바르지 않습니다.')
+          }
+          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('컴퓨터 신원 서비스에 연결할 수 없습니다. 잠시 후 다시 시도해 주세요.'))
+      } catch (lookupError) {
+        if (lookupError.code !== 'ENOENT') return reject(lookupError)
+        try {
+          if (await managedRevision() !== undefined) {
+            reject(new Error('컴퓨터 신원을 확인할 수 없습니다. 잠시 후 다시 시도하거나 소유자에게 문의해 주세요.'))
+          } else resolve(undefined)
+        } catch (error) { reject(error) }
+      }
+    })
+    req.setTimeout(10_000, () => req.destroy(new Error('컴퓨터 신원 응답 시간이 초과되었습니다.')))
+    req.end()
+  })).catch(error => {
+    error.hint = '컴퓨터 상태를 확인하고 다시 시도해 주세요. 차단되었다면 소유자 또는 조직 관리자에게 문의해 주세요.'
+    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 }
+}