Skip to content

nanocoai/nanoclaw / .claude/skills/add-onecli

add-onecli

Flagged

Install or refresh OneCLI as NanoClaw's gateway provider. Use when setup selects OneCLI, an existing OneCLI-backed install is migrated to the gateway seam, or its runtime, approval bridge, setup, and agent guidance must be restored from the in-tree package.

FileKindSize
REMOVE.mdmarkdown576 B
SKILL.mdskill md10.4 KB
apply-fixtures.jsonconfig1.9 KB
gateway.jsonconfig123 B
payload/docs/onecli-upgrades.mdmarkdown28.0 KB
payload/src/gateway-providers/onecli-chatgpt-stub.test.tsscript4.9 KB
payload/src/gateway-providers/onecli-chatgpt-stub.tsscript3.9 KB
payload/src/gateway-providers/onecli-files.test.tsscript4.4 KB
payload/src/gateway-providers/onecli-files.tsscript4.2 KB
payload/src/gateway-providers/onecli-install.test.tsscript1.1 KB
payload/src/gateway-providers/onecli-provider-credentials.test.tsscript7.6 KB
payload/src/gateway-providers/onecli-provider-credentials.tsscript9.6 KB
payload/src/gateway-providers/onecli.test.tsscript44.6 KB
payload/src/gateway-providers/onecli.tsscript18.2 KB
references/chatgpt-oauth-refresh.mdmarkdown1.1 KB
scripts/auth.test.tsscript10.1 KB
scripts/auth.tsscript7.5 KB
scripts/check-grants-gateway.shexecutablescript3.5 KB
scripts/credential-store.test.tsscript6.4 KB
scripts/credential-store.tsscript2.9 KB
scripts/detect.tsscript873 B
scripts/dial-key-check.shexecutablescript11.1 KB
scripts/install-claude.shexecutablescript1.6 KB
scripts/no-proxy.test.tsscript1.6 KB
scripts/post-upgrade-check.shexecutablescript2.7 KB
scripts/postgres-check.tsscript222 B
scripts/postgres-password.test.tsscript29.2 KB
scripts/postgres-password.tsscript20.2 KB
scripts/pre-upgrade-check.shexecutablescript2.9 KB
scripts/provider-credentials.test.tsscript21.9 KB
scripts/provider-credentials.tsscript12.7 KB
scripts/proxy-check.tsscript213 B
scripts/readiness.test.tsscript1.1 KB
scripts/register-claude-token.shexecutablescript4.0 KB
scripts/remote-proxy.test.tsscript10.9 KB
scripts/remote-proxy.tsscript4.2 KB
scripts/secret-input.test.tsscript10.4 KB
scripts/secret-input.tsscript4.9 KB
scripts/setup.tsscript23.1 KB
versions.jsonconfig84 B

scripts/credential-store.test.ts

View on GitHub
import { getProviderHostContract, registerProviderHostContract } from '../../../../src/provider-contracts/index.js';
if (!getProviderHostContract('codex'))
  registerProviderHostContract('codex', {
    ...getProviderHostContract('claude')!,
    modelDomains: ['openai.com', 'chatgpt.com'],
    modelEndpoints: {
      api: 'https://api.openai.com',
      subscription: 'https://chatgpt.com',
      token: 'https://auth.openai.com/oauth/token',
    },
  });
import fs from 'node:fs';
import os from 'node:os';
import path from 'node:path';
import { afterEach, expect, it, vi } from 'vitest';
const exec = vi.hoisted(() => vi.fn());
vi.mock('node:child_process', () => ({ execFileSync: exec }));
import { createCredentialStore } from './credential-store.js';
afterEach(() => vi.resetAllMocks());
it('passes API credentials in a private temporary file, never in argv, and removes it', async () => {
  let file = '';
  exec.mockImplementation((_bin, args) => {
    file = args[args.indexOf('--file') + 1];
    expect(fs.readFileSync(file, 'utf8')).toBe('fixture-key');
    expect(fs.statSync(file).mode & 0o777).toBe(0o600);
    expect(args).not.toContain('fixture-key');
  });
  await createCredentialStore().save('codex', { kind: 'api-key', value: 'fixture-key' });
  expect(fs.existsSync(file)).toBe(false);
});
it('counts only credentials Codex groups will be granted, records them, and fails explicitly without a vault', async () => {
  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-has-'));
  const record = () =>
    JSON.parse(fs.readFileSync(path.join(root, 'data', 'onecli', 'provider-credentials.json'), 'utf8')).providers;
  try {
    // OpenCode's credentials are not Codex's: Codex setup must still sign in.
    exec.mockReturnValueOnce(
      JSON.stringify({
        data: [
          { id: 'sec-oc', name: 'OpenCode openai', type: 'generic' },
          { id: 'sec-chatgpt', name: 'OpenCode ChatGPT', type: 'openai' },
        ],
      }),
    );
    expect(await createCredentialStore(root).has('codex')).toBe(false);
    // A credential Codex setup saved is counted and recorded, so a retried login repairs the record.
    exec.mockReturnValueOnce(JSON.stringify({ hint: 'h', data: [{ id: 'sec-codex', name: 'Codex', type: 'openai' }] }));
    expect(await createCredentialStore(root).has('codex')).toBe(true);
    expect(record()).toEqual({ codex: ['sec-codex'] });
    expect(exec.mock.calls.every(([, args]) => args.join(' ') === 'secrets list --max 0')).toBe(true);
  } finally {
    fs.rmSync(root, { recursive: true, force: true });
  }
  exec.mockImplementation(() => {
    throw new Error('fixture-private-error');
  });
  await expect(createCredentialStore().has('codex')).rejects.toThrow('Cannot read the selected OneCLI vault');
});
it('records the created Codex secret id so Codex groups are granted it, and only after a successful save', async () => {
  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-record-'));
  const file = path.join(root, 'data', 'onecli', 'provider-credentials.json');
  try {
    exec.mockReturnValueOnce('{\n  "hint": "attach it",\n  "id": "sec-codex"\n}');
    await createCredentialStore(root).save('codex', { kind: 'api-key', value: 'fixture-key' });
    expect(JSON.parse(fs.readFileSync(file, 'utf8')).providers).toEqual({ codex: ['sec-codex'] });
    fs.rmSync(path.join(root, 'data'), { recursive: true });
    exec.mockReturnValueOnce('not json');
    await createCredentialStore(root).save('codex', { kind: 'api-key', value: 'fixture-key' });
    exec.mockImplementationOnce(() => {
      throw new Error('fixture-private-error');
    });
    await expect(createCredentialStore(root).save('codex', { kind: 'api-key', value: 'k' })).rejects.toThrow(
      'Cannot save Codex credentials',
    );
    expect(fs.existsSync(file)).toBe(false);
  } finally {
    fs.rmSync(root, { recursive: true, force: true });
  }
});

it('Codex: a recorded id counts as connected; duplicate names without one do not, and nothing is recorded', async () => {
  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-dupes-'));
  const file = path.join(root, 'data', 'onecli', 'provider-credentials.json');
  try {
    exec.mockReturnValueOnce(
      JSON.stringify({
        data: [
          { id: 'c1', name: 'Codex' },
          { id: 'c2', name: 'Codex' },
        ],
      }),
    );
    expect(await createCredentialStore(root).has('codex')).toBe(false);
    expect(fs.existsSync(file)).toBe(false);
    fs.mkdirSync(path.dirname(file), { recursive: true });
    fs.writeFileSync(file, JSON.stringify({ providers: { codex: ['c1'] }, matched: [] }));
    exec.mockReturnValueOnce(
      JSON.stringify({
        data: [
          { id: 'c1', name: 'Codex' },
          { id: 'c2', name: 'Codex' },
        ],
      }),
    );
    expect(await createCredentialStore(root).has('codex')).toBe(true);
    expect(JSON.parse(fs.readFileSync(file, 'utf8')).providers).toEqual({ codex: ['c1'] });
  } finally {
    fs.rmSync(root, { recursive: true, force: true });
  }
});

it('Codex: a recorded id that left the vault is not replaced by another install’s same-named key', async () => {
  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-gone-'));
  const file = path.join(root, 'data', 'onecli', 'provider-credentials.json');
  try {
    fs.mkdirSync(path.dirname(file), { recursive: true });
    fs.writeFileSync(file, JSON.stringify({ providers: { codex: ['c-gone'] }, matched: ['codex'] }));
    exec.mockReturnValueOnce(JSON.stringify({ data: [{ id: 'c-other', name: 'Codex' }] }));
    expect(await createCredentialStore(root).has('codex')).toBe(false);
    expect(JSON.parse(fs.readFileSync(file, 'utf8')).providers).toEqual({ codex: ['c-gone'] });
  } finally {
    fs.rmSync(root, { recursive: true, force: true });
  }
});

it('Codex: after the one-time match found nothing, a later same-named key is not adopted', async () => {
  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'codex-matched-'));
  const file = path.join(root, 'data', 'onecli', 'provider-credentials.json');
  try {
    fs.mkdirSync(path.dirname(file), { recursive: true });
    fs.writeFileSync(file, JSON.stringify({ providers: { codex: [] }, matched: ['codex'] }));
    exec.mockReturnValueOnce(JSON.stringify({ data: [{ id: 'c-other', name: 'Codex' }] }));
    expect(await createCredentialStore(root).has('codex')).toBe(false);
    expect(JSON.parse(fs.readFileSync(file, 'utf8')).providers).toEqual({ codex: [] });
  } finally {
    fs.rmSync(root, { recursive: true, force: true });
  }
});
reverse-engineer-anythingmorluto/reaReverse engineer native, managed, Electron/JavaScript, packaged, firmware, and browser targets with REA, and build agent environments (AgentEnv bundles) of web applications from a live instance or a capture, and of Linux desktop apps with a task from a request. Use shipped-artifact or requested runtime evidence to explain features, compare versions, decompile code, or guide a reconstruction. Skip REA for ordinary source-repository architecture analysis.Stars: 471kUpdated Claude CodeCodexVerifiedInstall
diagnosing-superpowersobra/superpowersUse when a superpowers session went wrong and your human partner wants to know why — repeated work, ignored plans, stumbles, poor results, a skill that didn't fire, "it took too long", "why is it so expensive", "what is it doing" — or wants to build a bug report for the superpowers maintainers, for the current session or a past one identified by id or path, on any harness.Stars: 322kUpdated Claude CodeCodexVerifiedInstall
dispatching-parallel-agentsobra/superpowersUse when facing 2+ independent tasks that can be worked on without shared state or sequential dependenciesStars: 322kUpdated Claude CodeCodexVerifiedInstall
executing-plansobra/superpowersUse when executing an implementation plan in the current session as the implementer yourself — your human partner chose inline execution, or no subagent tool is availableStars: 322kUpdated Claude CodeCodexVerifiedInstall