workar 0.1.0

package/README.md

@@ -0,0 +1,58 @@
+# workar
+
+End-user CLI for the distributed work system.
+
+## Setup
+
+```bash
+npm install
+npm run build
+```
+
+## Usage
+
+### Register a user
+
+```bash
+workar register --username alice [--server http://localhost:8787]
+```
+
+Writes `~/.workar/config.json` with `username`, `apiKey`, and `serverUrl`.
+
+### Authenticate (get a JWT)
+
+```bash
+workar auth [--username alice] [--api-key <key>]
+```
+
+Writes the JWT to `~/.workar/config.json`.
+
+### Submit work
+
+```bash
+workar submit --type image-gen --wait [--out-dir ./output] -- prompt="a red panda" model=sdxl-lightning
+```
+
+Key-value pairs after `--` are passed as work fields. `--wait` polls for the
+result and saves it as `work-<workId>.<ext>` in `--out-dir` (default: CWD).
+
+### Retrieve a result
+
+```bash
+workar get [--work-id <id>] [--wait] [--out-dir ./output]
+```
+
+## Config file
+
+`~/.workar/config.json` (chmod 600):
+
+```json
+{
+  "serverUrl": "https://...",
+  "username": "alice",
+  "apiKey": "...",
+  "jwt": "..."
+}
+```
+
+Flags `--server`, `--username`, `--api-key` override the file values.

package/dist/api.d.ts

@@ -0,0 +1,21 @@
+export declare class ClientApi {
+    private readonly serverUrl;
+    private readonly authHeaders;
+    constructor(serverUrl: string, authHeaders: Record<string, string>);
+    register(username: string): Promise<{
+        username: string;
+        apiKey: string;
+    }>;
+    auth(username: string, apiKey: string): Promise<{
+        jwt: string;
+    }>;
+    submitWork(body: Record<string, unknown>): Promise<{
+        workId: string;
+    }>;
+    getWork(poll: boolean, workId?: string): Promise<{
+        workId: string;
+        contentType: string;
+        bytes: Uint8Array;
+        isError: boolean;
+    }>;
+}

package/dist/api.js

@@ -0,0 +1,77 @@
+export class ClientApi {
+    serverUrl;
+    authHeaders;
+    constructor(serverUrl, authHeaders) {
+        this.serverUrl = serverUrl;
+        this.authHeaders = authHeaders;
+    }
+    async register(username) {
+        const res = await fetch(`${this.serverUrl}/api/users`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ username }),
+        });
+        const data = (await res.json());
+        if (!res.ok)
+            throw new Error(data['error'] ?? `HTTP ${res.status}`);
+        return data;
+    }
+    async auth(username, apiKey) {
+        const res = await fetch(`${this.serverUrl}/api/auth`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: JSON.stringify({ username, apiKey }),
+        });
+        const data = (await res.json());
+        if (!res.ok)
+            throw new Error(data['error'] ?? `HTTP ${res.status}`);
+        return data;
+    }
+    async submitWork(body) {
+        const res = await fetch(`${this.serverUrl}/api/work`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json', ...this.authHeaders },
+            body: JSON.stringify(body),
+        });
+        const data = (await res.json());
+        if (!res.ok)
+            throw new Error(data['error'] ?? `HTTP ${res.status}`);
+        return data;
+    }
+    async getWork(poll, workId) {
+        const params = new URLSearchParams();
+        if (workId)
+            params.set('workId', workId);
+        const qs = params.toString();
+        const url = `${this.serverUrl}/api/work${qs ? `?${qs}` : ''}`;
+        const maxWaitMs = 30 * 60 * 1000; // 30 minutes
+        const retryIntervalMs = 10 * 1000; // 10 seconds between retries
+        const startTime = Date.now();
+        let attempt = 0;
+        while (true) {
+            attempt++;
+            const res = await fetch(url, { headers: this.authHeaders });
+            if (res.status === 404) {
+                if (!poll || Date.now() - startTime >= maxWaitMs) {
+                    throw new Error('No work result available (404)');
+                }
+                if (attempt === 1)
+                    process.stdout.write('Waiting for result');
+                process.stdout.write('.');
+                await new Promise((resolve) => setTimeout(resolve, retryIntervalMs));
+                continue;
+            }
+            if (attempt > 1)
+                process.stdout.write('\n');
+            if (!res.ok) {
+                const data = (await res.json().catch(() => ({})));
+                throw new Error(data['error'] ?? `HTTP ${res.status}`);
+            }
+            const isError = res.headers.get('x-work-error') === '1';
+            const retWorkId = res.headers.get('x-work-id') ?? '';
+            const contentType = res.headers.get('content-type') ?? 'application/octet-stream';
+            const bytes = new Uint8Array(await res.arrayBuffer());
+            return { workId: retWorkId, contentType, bytes, isError };
+        }
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { cmdRegister } from './commands/register.js';
+import { cmdAuth } from './commands/auth.js';
+import { cmdSubmit } from './commands/submit.js';
+import { cmdGet } from './commands/get.js';
+const [subcommand, ...restArgs] = process.argv.slice(2);
+switch (subcommand) {
+    case 'register': {
+        const { values } = parseArgs({
+            args: restArgs,
+            options: {
+                username: { type: 'string' },
+                server: { type: 'string' },
+            },
+        });
+        await cmdRegister(values);
+        break;
+    }
+    case 'auth': {
+        const { values } = parseArgs({
+            args: restArgs,
+            options: {
+                username: { type: 'string' },
+                'api-key': { type: 'string' },
+                server: { type: 'string' },
+            },
+        });
+        await cmdAuth(values);
+        break;
+    }
+    case 'submit': {
+        const { values, positionals } = parseArgs({
+            args: restArgs,
+            options: {
+                type: { type: 'string' },
+                wait: { type: 'boolean', default: false },
+                'out-dir': { type: 'string' },
+                server: { type: 'string' },
+                'api-key': { type: 'string' },
+            },
+            allowPositionals: true,
+        });
+        await cmdSubmit({
+            ...values,
+            positionals,
+        });
+        break;
+    }
+    case 'get': {
+        const { values } = parseArgs({
+            args: restArgs,
+            options: {
+                'work-id': { type: 'string' },
+                wait: { type: 'boolean', default: false },
+                'out-dir': { type: 'string' },
+                server: { type: 'string' },
+                'api-key': { type: 'string' },
+            },
+        });
+        await cmdGet(values);
+        break;
+    }
+    default: {
+        console.error(`Unknown subcommand: ${subcommand ?? '(none)'}`);
+        console.error('Usage: tarsk <register|auth|submit|get> [options]');
+        process.exit(1);
+    }
+}

package/dist/commands/auth.d.ts

@@ -0,0 +1,5 @@
+export declare function cmdAuth(args: {
+    username?: string;
+    'api-key'?: string;
+    server?: string;
+}): Promise<void>;

package/dist/commands/auth.js

@@ -0,0 +1,20 @@
+import { readConfig, writeConfig, getServerUrl } from '../config.js';
+import { ClientApi } from '../api.js';
+export async function cmdAuth(args) {
+    const config = await readConfig();
+    const serverUrl = getServerUrl(config, args);
+    const username = args.username ?? config.username;
+    const apiKey = args['api-key'] ?? config.apiKey;
+    if (!username) {
+        console.error('Error: --username is required (or run `tarsk register` first)');
+        process.exit(1);
+    }
+    if (!apiKey) {
+        console.error('Error: --api-key is required (or run `tarsk register` first)');
+        process.exit(1);
+    }
+    const api = new ClientApi(serverUrl, {});
+    const result = await api.auth(username, apiKey);
+    await writeConfig({ ...config, jwt: result.jwt });
+    console.log('Authenticated successfully');
+}

package/dist/commands/get.d.ts

@@ -0,0 +1,7 @@
+export declare function cmdGet(args: {
+    'work-id'?: string;
+    wait?: boolean;
+    'out-dir'?: string;
+    server?: string;
+    'api-key'?: string;
+}): Promise<void>;

package/dist/commands/get.js

@@ -0,0 +1,16 @@
+import { mkdir } from 'node:fs/promises';
+import { readConfig, getServerUrl, buildAuthHeaders } from '../config.js';
+import { ClientApi } from '../api.js';
+import { saveResult } from '../output.js';
+export async function cmdGet(args) {
+    const config = await readConfig();
+    const serverUrl = getServerUrl(config, args);
+    const authHeaders = buildAuthHeaders(config, { 'api-key': args['api-key'] });
+    const api = new ClientApi(serverUrl, authHeaders);
+    const outDir = args['out-dir'] ?? process.cwd();
+    await mkdir(outDir, { recursive: true });
+    const result = await api.getWork(args.wait ?? false, args['work-id']);
+    await saveResult(result, outDir);
+    if (result.isError)
+        process.exit(1);
+}

package/dist/commands/register.d.ts

@@ -0,0 +1,4 @@
+export declare function cmdRegister(args: {
+    username?: string;
+    server?: string;
+}): Promise<void>;

package/dist/commands/register.js

@@ -0,0 +1,15 @@
+import { readConfig, writeConfig, getServerUrl } from '../config.js';
+import { ClientApi } from '../api.js';
+export async function cmdRegister(args) {
+    if (!args.username) {
+        console.error('Error: --username is required');
+        process.exit(1);
+    }
+    const config = await readConfig();
+    const serverUrl = getServerUrl(config, args);
+    const api = new ClientApi(serverUrl, {});
+    const result = await api.register(args.username);
+    await writeConfig({ ...config, serverUrl, username: result.username, apiKey: result.apiKey });
+    console.log(`Registered as ${result.username}`);
+    console.log(`API key: ${result.apiKey}`);
+}

package/dist/commands/submit.d.ts

@@ -0,0 +1,8 @@
+export declare function cmdSubmit(args: {
+    type?: string;
+    wait?: boolean;
+    'out-dir'?: string;
+    server?: string;
+    'api-key'?: string;
+    positionals?: string[];
+}): Promise<void>;

package/dist/commands/submit.js

@@ -0,0 +1,33 @@
+import { mkdir } from 'node:fs/promises';
+import { readConfig, getServerUrl, buildAuthHeaders } from '../config.js';
+import { ClientApi } from '../api.js';
+import { saveResult } from '../output.js';
+export async function cmdSubmit(args) {
+    if (!args.type) {
+        console.error('Error: --type is required');
+        process.exit(1);
+    }
+    const config = await readConfig();
+    const serverUrl = getServerUrl(config, args);
+    const authHeaders = buildAuthHeaders(config, { 'api-key': args['api-key'] });
+    const api = new ClientApi(serverUrl, authHeaders);
+    const kv = {};
+    for (const pair of args.positionals ?? []) {
+        const eq = pair.indexOf('=');
+        if (eq === -1) {
+            console.error(`Invalid key=value pair: ${pair}`);
+            process.exit(1);
+        }
+        kv[pair.slice(0, eq)] = pair.slice(eq + 1);
+    }
+    const { workId } = await api.submitWork({ type: args.type, ...kv });
+    console.log(`Submitted work ${workId}`);
+    if (args.wait) {
+        const outDir = args['out-dir'] ?? process.cwd();
+        await mkdir(outDir, { recursive: true });
+        const result = await api.getWork(true, workId);
+        await saveResult(result, outDir);
+        if (result.isError)
+            process.exit(1);
+    }
+}

package/dist/config.d.ts

@@ -0,0 +1,14 @@
+export interface ClientConfig {
+    serverUrl?: string;
+    username?: string;
+    apiKey?: string;
+    jwt?: string;
+}
+export declare function readConfig(): Promise<ClientConfig>;
+export declare function writeConfig(config: ClientConfig): Promise<void>;
+export declare function getServerUrl(config: ClientConfig, overrides: {
+    server?: string;
+}): string;
+export declare function buildAuthHeaders(config: ClientConfig, overrides: {
+    'api-key'?: string;
+}): Record<string, string>;

package/dist/config.js

@@ -0,0 +1,27 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+const CONFIG_DIR = path.join(homedir(), '.tarsk-work');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+export async function readConfig() {
+    if (!existsSync(CONFIG_FILE))
+        return {};
+    const raw = await readFile(CONFIG_FILE, 'utf-8');
+    return JSON.parse(raw);
+}
+export async function writeConfig(config) {
+    await mkdir(CONFIG_DIR, { recursive: true });
+    await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+export function getServerUrl(config, overrides) {
+    return overrides.server ?? config.serverUrl ?? 'https://work.tarsk.io';
+}
+export function buildAuthHeaders(config, overrides) {
+    const apiKey = overrides['api-key'] ?? config.apiKey;
+    if (apiKey)
+        return { 'x-api-key': apiKey };
+    if (config.jwt)
+        return { authorization: `Bearer ${config.jwt}` };
+    throw new Error('No authentication available. Run `tarsk register` then `tarsk auth`.');
+}

package/dist/output.d.ts

@@ -0,0 +1,6 @@
+export declare function saveResult(result: {
+    workId: string;
+    contentType: string;
+    bytes: Uint8Array;
+    isError: boolean;
+}, outDir: string): Promise<string>;

package/dist/output.js

@@ -0,0 +1,25 @@
+import { writeFile } from 'node:fs/promises';
+import path from 'node:path';
+const EXT_MAP = {
+    'image/png': 'png',
+    'image/jpeg': 'jpg',
+    'image/webp': 'webp',
+    'application/json': 'json',
+    'text/plain': 'txt',
+};
+function extFor(contentType) {
+    const base = contentType.split(';')[0].trim();
+    return EXT_MAP[base] ?? 'bin';
+}
+export async function saveResult(result, outDir) {
+    const ext = extFor(result.contentType);
+    const filename = `work-${result.workId}.${ext}`;
+    const filePath = path.join(outDir, filename);
+    await writeFile(filePath, result.bytes);
+    console.log(`I saved the result to "${filePath}"`);
+    if (result.isError) {
+        const errData = JSON.parse(new TextDecoder().decode(result.bytes));
+        console.error(`Error: ${errData.message ?? 'unknown error'}`);
+    }
+    return filePath;
+}

package/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "workar",
+  "version": "0.1.0",
+  "type": "module",
+  "bin": {
+    "workar": "./dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc && node -e \"const fs=require('fs');const f='dist/cli.js';fs.writeFileSync(f,'#!/usr/bin/env node\\n'+fs.readFileSync(f,'utf8'))\"",
+    "start": "node dist/cli.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  }
+}

package/src/api.ts

@@ -0,0 +1,87 @@
+export class ClientApi {
+  constructor(
+    private readonly serverUrl: string,
+    private readonly authHeaders: Record<string, string>,
+  ) {}
+
+  async register(username: string): Promise<{ username: string; apiKey: string }> {
+    const res = await fetch(`${this.serverUrl}/api/users`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ username }),
+    });
+    const data = (await res.json()) as Record<string, unknown>;
+    if (!res.ok) throw new Error((data['error'] as string) ?? `HTTP ${res.status}`);
+    return data as { username: string; apiKey: string };
+  }
+
+  async auth(username: string, apiKey: string): Promise<{ jwt: string }> {
+    const res = await fetch(`${this.serverUrl}/api/auth`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ username, apiKey }),
+    });
+    const data = (await res.json()) as Record<string, unknown>;
+    if (!res.ok) throw new Error((data['error'] as string) ?? `HTTP ${res.status}`);
+    return data as { jwt: string };
+  }
+
+  async submitWork(body: Record<string, unknown>): Promise<{ workId: string }> {
+    const res = await fetch(`${this.serverUrl}/api/work`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', ...this.authHeaders },
+      body: JSON.stringify(body),
+    });
+    const data = (await res.json()) as Record<string, unknown>;
+    if (!res.ok) throw new Error((data['error'] as string) ?? `HTTP ${res.status}`);
+    return data as { workId: string };
+  }
+
+  async getWork(
+    poll: boolean,
+    workId?: string,
+  ): Promise<{
+    workId: string;
+    contentType: string;
+    bytes: Uint8Array;
+    isError: boolean;
+  }> {
+    const params = new URLSearchParams();
+    if (workId) params.set('workId', workId);
+    const qs = params.toString();
+    const url = `${this.serverUrl}/api/work${qs ? `?${qs}` : ''}`;
+
+    const maxWaitMs = 30 * 60 * 1000; // 30 minutes
+    const retryIntervalMs = 10 * 1000; // 10 seconds between retries
+    const startTime = Date.now();
+    let attempt = 0;
+
+    while (true) {
+      attempt++;
+      const res = await fetch(url, { headers: this.authHeaders });
+
+      if (res.status === 404) {
+        if (!poll || Date.now() - startTime >= maxWaitMs) {
+          throw new Error('No work result available (404)');
+        }
+        if (attempt === 1) process.stdout.write('Waiting for result');
+        process.stdout.write('.');
+        await new Promise<void>((resolve) => setTimeout(resolve, retryIntervalMs));
+        continue;
+      }
+
+      if (attempt > 1) process.stdout.write('\n');
+
+      if (!res.ok) {
+        const data = (await res.json().catch(() => ({}))) as Record<string, unknown>;
+        throw new Error((data['error'] as string) ?? `HTTP ${res.status}`);
+      }
+
+      const isError = res.headers.get('x-work-error') === '1';
+      const retWorkId = res.headers.get('x-work-id') ?? '';
+      const contentType = res.headers.get('content-type') ?? 'application/octet-stream';
+      const bytes = new Uint8Array(await res.arrayBuffer());
+      return { workId: retWorkId, contentType, bytes, isError };
+    }
+  }
+}

package/src/cli.ts

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import { parseArgs } from 'node:util';
+import { cmdRegister } from './commands/register.js';
+import { cmdAuth } from './commands/auth.js';
+import { cmdSubmit } from './commands/submit.js';
+import { cmdGet } from './commands/get.js';
+
+const [subcommand, ...restArgs] = process.argv.slice(2);
+
+switch (subcommand) {
+  case 'register': {
+    const { values } = parseArgs({
+      args: restArgs,
+      options: {
+        username: { type: 'string' },
+        server: { type: 'string' },
+      },
+    });
+    await cmdRegister(values as { username?: string; server?: string });
+    break;
+  }
+
+  case 'auth': {
+    const { values } = parseArgs({
+      args: restArgs,
+      options: {
+        username: { type: 'string' },
+        'api-key': { type: 'string' },
+        server: { type: 'string' },
+      },
+    });
+    await cmdAuth(values as { username?: string; 'api-key'?: string; server?: string });
+    break;
+  }
+
+  case 'submit': {
+    const { values, positionals } = parseArgs({
+      args: restArgs,
+      options: {
+        type: { type: 'string' },
+        wait: { type: 'boolean', default: false },
+        'out-dir': { type: 'string' },
+        server: { type: 'string' },
+        'api-key': { type: 'string' },
+      },
+      allowPositionals: true,
+    });
+    await cmdSubmit({
+      ...(values as {
+        type?: string;
+        wait?: boolean;
+        'out-dir'?: string;
+        server?: string;
+        'api-key'?: string;
+      }),
+      positionals,
+    });
+    break;
+  }
+
+  case 'get': {
+    const { values } = parseArgs({
+      args: restArgs,
+      options: {
+        'work-id': { type: 'string' },
+        wait: { type: 'boolean', default: false },
+        'out-dir': { type: 'string' },
+        server: { type: 'string' },
+        'api-key': { type: 'string' },
+      },
+    });
+    await cmdGet(
+      values as {
+        'work-id'?: string;
+        wait?: boolean;
+        'out-dir'?: string;
+        server?: string;
+        'api-key'?: string;
+      },
+    );
+    break;
+  }
+
+  default: {
+    console.error(`Unknown subcommand: ${subcommand ?? '(none)'}`);
+    console.error('Usage: tarsk <register|auth|submit|get> [options]');
+    process.exit(1);
+  }
+}

package/src/commands/auth.ts

@@ -0,0 +1,27 @@
+import { readConfig, writeConfig, getServerUrl } from '../config.js';
+import { ClientApi } from '../api.js';
+
+export async function cmdAuth(args: {
+  username?: string;
+  'api-key'?: string;
+  server?: string;
+}): Promise<void> {
+  const config = await readConfig();
+  const serverUrl = getServerUrl(config, args);
+  const username = args.username ?? config.username;
+  const apiKey = args['api-key'] ?? config.apiKey;
+
+  if (!username) {
+    console.error('Error: --username is required (or run `workar register` first)');
+    process.exit(1);
+  }
+  if (!apiKey) {
+    console.error('Error: --api-key is required (or run `workar register` first)');
+    process.exit(1);
+  }
+
+  const api = new ClientApi(serverUrl, {});
+  const result = await api.auth(username, apiKey);
+  await writeConfig({ ...config, jwt: result.jwt });
+  console.log('Authenticated successfully');
+}

package/src/commands/get.ts

@@ -0,0 +1,24 @@
+import { mkdir } from 'node:fs/promises';
+import { readConfig, getServerUrl, buildAuthHeaders } from '../config.js';
+import { ClientApi } from '../api.js';
+import { saveResult } from '../output.js';
+
+export async function cmdGet(args: {
+  'work-id'?: string;
+  wait?: boolean;
+  'out-dir'?: string;
+  server?: string;
+  'api-key'?: string;
+}): Promise<void> {
+  const config = await readConfig();
+  const serverUrl = getServerUrl(config, args);
+  const authHeaders = buildAuthHeaders(config, { 'api-key': args['api-key'] });
+  const api = new ClientApi(serverUrl, authHeaders);
+
+  const outDir = args['out-dir'] ?? process.cwd();
+  await mkdir(outDir, { recursive: true });
+
+  const result = await api.getWork(args.wait ?? false, args['work-id']);
+  await saveResult(result, outDir);
+  if (result.isError) process.exit(1);
+}

package/src/commands/register.ts

@@ -0,0 +1,20 @@
+import { readConfig, writeConfig, getServerUrl } from '../config.js';
+import { ClientApi } from '../api.js';
+
+export async function cmdRegister(args: {
+  username?: string;
+  server?: string;
+}): Promise<void> {
+  if (!args.username) {
+    console.error('Error: --username is required');
+    process.exit(1);
+  }
+
+  const config = await readConfig();
+  const serverUrl = getServerUrl(config, args);
+  const api = new ClientApi(serverUrl, {});
+  const result = await api.register(args.username);
+  await writeConfig({ ...config, serverUrl, username: result.username, apiKey: result.apiKey });
+  console.log(`Registered as ${result.username}`);
+  console.log(`API key: ${result.apiKey}`);
+}

package/src/commands/submit.ts

@@ -0,0 +1,44 @@
+import { mkdir } from 'node:fs/promises';
+import { readConfig, getServerUrl, buildAuthHeaders } from '../config.js';
+import { ClientApi } from '../api.js';
+import { saveResult } from '../output.js';
+
+export async function cmdSubmit(args: {
+  type?: string;
+  wait?: boolean;
+  'out-dir'?: string;
+  server?: string;
+  'api-key'?: string;
+  positionals?: string[];
+}): Promise<void> {
+  if (!args.type) {
+    console.error('Error: --type is required');
+    process.exit(1);
+  }
+
+  const config = await readConfig();
+  const serverUrl = getServerUrl(config, args);
+  const authHeaders = buildAuthHeaders(config, { 'api-key': args['api-key'] });
+  const api = new ClientApi(serverUrl, authHeaders);
+
+  const kv: Record<string, string> = {};
+  for (const pair of args.positionals ?? []) {
+    const eq = pair.indexOf('=');
+    if (eq === -1) {
+      console.error(`Invalid key=value pair: ${pair}`);
+      process.exit(1);
+    }
+    kv[pair.slice(0, eq)] = pair.slice(eq + 1);
+  }
+
+  const { workId } = await api.submitWork({ type: args.type, ...kv });
+  console.log(`Submitted work ${workId}`);
+
+  if (args.wait) {
+    const outDir = args['out-dir'] ?? process.cwd();
+    await mkdir(outDir, { recursive: true });
+    const result = await api.getWork(true, workId);
+    await saveResult(result, outDir);
+    if (result.isError) process.exit(1);
+  }
+}

package/src/config.ts

@@ -0,0 +1,42 @@
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
+import path from 'node:path';
+
+export interface ClientConfig {
+  serverUrl?: string;
+  username?: string;
+  apiKey?: string;
+  jwt?: string;
+}
+
+const CONFIG_DIR = path.join(homedir(), '.workar');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+
+export async function readConfig(): Promise<ClientConfig> {
+  if (!existsSync(CONFIG_FILE)) return {};
+  const raw = await readFile(CONFIG_FILE, 'utf-8');
+  return JSON.parse(raw) as ClientConfig;
+}
+
+export async function writeConfig(config: ClientConfig): Promise<void> {
+  await mkdir(CONFIG_DIR, { recursive: true });
+  await writeFile(CONFIG_FILE, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+
+export function getServerUrl(
+  config: ClientConfig,
+  overrides: { server?: string },
+): string {
+  return overrides.server ?? config.serverUrl ?? 'https://workar.tarsk.io';
+}
+
+export function buildAuthHeaders(
+  config: ClientConfig,
+  overrides: { 'api-key'?: string },
+): Record<string, string> {
+  const apiKey = overrides['api-key'] ?? config.apiKey;
+  if (apiKey) return { 'x-api-key': apiKey };
+  if (config.jwt) return { authorization: `Bearer ${config.jwt}` };
+  throw new Error('No authentication available. Run `workar register` then `workar auth`.');
+}

package/src/output.ts

@@ -0,0 +1,35 @@
+import { writeFile } from 'node:fs/promises';
+import path from 'node:path';
+
+const EXT_MAP: Record<string, string> = {
+  'image/png': 'png',
+  'image/jpeg': 'jpg',
+  'image/webp': 'webp',
+  'application/json': 'json',
+  'text/plain': 'txt',
+};
+
+function extFor(contentType: string): string {
+  const base = contentType.split(';')[0].trim();
+  return EXT_MAP[base] ?? 'bin';
+}
+
+export async function saveResult(
+  result: { workId: string; contentType: string; bytes: Uint8Array; isError: boolean },
+  outDir: string,
+): Promise<string> {
+  const ext = extFor(result.contentType);
+  const filename = `work-${result.workId}.${ext}`;
+  const filePath = path.join(outDir, filename);
+  await writeFile(filePath, result.bytes);
+  console.log(`I saved the result to "${filePath}"`);
+
+  if (result.isError) {
+    const errData = JSON.parse(new TextDecoder().decode(result.bytes)) as {
+      message?: string;
+    };
+    console.error(`Error: ${errData.message ?? 'unknown error'}`);
+  }
+
+  return filePath;
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "rootDir": "src",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}