gemiterm 2.0.0 → 2.1.0

package/README.md

@@ -4,13 +4,37 @@ Access and manage your Gemini web chats from the command line. GemiTerm bridges
 
 ## Prerequisites
 
-- **[Bun](https://bun.sh)** runtime
+- **[Bun](https://bun.sh)** runtime ≥ 1.0.0
 - **Chromium Browser** — GemiTerm uses your system Chrome/Edge if available, otherwise installs Playwright's Chromium automatically
 - **Google Account** with access to [Gemini](https://gemini.google.com)
 
+## Quick Start (no install)
+
+Use `bunx` to run GemiTerm directly — no install step needed:
+
+```bash
+bunx gemiterm auth          # authenticate with Google
+bunx gemiterm list          # list your chats
+```
+
 ## Installation
 
-See [docs/INSTALL.md](docs/INSTALL.md) for the full guide, uninstall instructions, troubleshooting, and build-from-source steps.
+### Global install (recommended for daily use)
+
+```bash
+bun install gemiterm -g
+```
+
+Then use from anywhere:
+
+```bash
+gemiterm auth
+gemiterm list
+```
+
+### Install scripts (binary drop)
+
+For systems without Bun — the script auto-bootstraps Bun if needed.
 
 **Windows** (PowerShell 7+):
 
@@ -24,14 +48,9 @@ irm https://github.com/expert-vision-software/GemiTerm/releases/latest/download/
 curl -fsSL https://github.com/expert-vision-software/GemiTerm/releases/latest/download/install.sh | bash
 ```
 
-> **Upgrading from v1.4.1?** Your profiles, cookies, and default profile marker are preserved. The installer replaces the binary in place; it does NOT touch your config dir. See the "Upgrade from v1.4.1" section in [docs/INSTALL.md](docs/INSTALL.md) for details.
-
-## Quick Start
+See [docs/INSTALL.md](docs/INSTALL.md) for the full guide, uninstall instructions, troubleshooting, and build-from-source steps.
 
-```bash
-gemiterm auth          # authenticate with Google
-gemiterm list          # list your chats
-```
+> **Upgrading from v1.4.1?** Your profiles, cookies, and default profile marker are preserved. See the "Upgrade from v1.4.1" section in [docs/INSTALL.md](docs/INSTALL.md) for details.
 
 ## Development
 
@@ -197,6 +216,10 @@ Checks for system Chrome/Edge first, falls back to installing Playwright's Chrom
 gemiterm -v <command>
 ```
 
+## Skills
+
+GemiTerm has an associated skills repository for AI coding agents (Copilot, Claude, etc.) that provides domain-specific instructions for working with **gemiterm** and automating common workflows. There's also a fun `debate-with-gemini` skill that created an interactive turn-based conversation between your agent and gemini. See [opencode-gemiterm-skills](https://www.npmjs.com/package/opencode-gemiterm-skills).
+
 ## Configuration
 
 ### Configuration Directory

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gemiterm",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "module": "index.ts",
   "type": "module",
   "repository": {
@@ -14,9 +14,16 @@
   "publishConfig": {
     "access": "public"
   },
-  "devDependencies": {
-    "@types/bun": "^1.3.14"
+  "bin": {
+    "gemiterm": "src/cli/index.ts"
+  },
+  "engines": {
+    "bun": ">=1.0.0"
   },
+  "files": [
+    "src/",
+    "README.md"
+  ],
   "scripts": {
     "start": "bun run src/cli/index.ts",
     "dev": "bun run src/cli/index.ts",
@@ -34,12 +41,14 @@
     "build:windows": "bun run scripts/build.ts windows",
     "build:release": "bun run scripts/build.ts release"
   },
-  "peerDependencies": {
+  "devDependencies": {
+    "@types/bun": "^1.3.14",
     "typescript": "^6.0.3"
   },
   "dependencies": {
     "chalk": "^5.6.2",
     "cli-table3": "^0.6.5",
+    "commander": "^15.0.0",
     "gemini-reverse": "^1.0.12"
   }
 }

package/src/cli/command-registry.ts

@@ -1,62 +1,66 @@
-import type { Mediator } from "../core/mediator.ts";
-import type { ProfileAuthManager } from "../services/profile-auth-manager.ts";
-import { AuthCommand } from "./commands/auth-command.ts";
-import { ProfileCommand } from "./commands/profile-command.ts";
-import { StatusCommand } from "./commands/status-command.ts";
-import { ListCommand } from "./commands/list-command.ts";
-import { FetchCommand } from "./commands/fetch-command.ts";
-import { ContinueCommand } from "./commands/continue-command.ts";
-import { NewCommand } from "./commands/new-command.ts";
-import { DeleteCommand } from "./commands/delete-command.ts";
-import { ExportCommand } from "./commands/export-command.ts";
-import { ExportAllCommand } from "./commands/export-all-command.ts";
-import { InstallBrowserCommand } from "./commands/install-browser-command.ts";
-
-export interface CliCommandContext {
-  verbose: boolean;
-  mediator: Mediator;
-  profileAuthManager: ProfileAuthManager;
-}
-
-export interface CliCommand {
-  readonly name: string;
-  readonly description: string;
-  execute(args: string[], context: CliCommandContext): Promise<void>;
-}
-
-export class CommandRegistry {
-  private handlers = new Map<string, CliCommand>();
-
-  register(commandName: string, handler: CliCommand): void {
-    if (this.handlers.has(commandName)) {
-      throw new Error(`Command already registered: ${commandName}`);
-    }
-    this.handlers.set(commandName, handler);
-  }
-
-  getHandler(commandName: string): CliCommand | undefined {
-    return this.handlers.get(commandName);
-  }
-
-  has(commandName: string): boolean {
-    return this.handlers.has(commandName);
-  }
-
-  getRegisteredNames(): string[] {
-    return [...this.handlers.keys()];
-  }
-
-  registerAllCommands(): void {
-    this.register("auth", new AuthCommand());
-    this.register("profile", new ProfileCommand());
-    this.register("status", new StatusCommand());
-    this.register("list", new ListCommand());
-    this.register("fetch", new FetchCommand());
-    this.register("continue", new ContinueCommand());
-    this.register("new", new NewCommand());
-    this.register("delete", new DeleteCommand());
-    this.register("export", new ExportCommand());
-    this.register("export-all", new ExportAllCommand());
-    this.register("install-browser", new InstallBrowserCommand());
-  }
-}
+import type { Mediator } from "../core/mediator.ts";
+import type { ProfileAuthManager } from "../services/profile-auth-manager.ts";
+import { AuthCommand } from "./commands/auth-command.ts";
+import { ProfileCommand } from "./commands/profile-command.ts";
+import { StatusCommand } from "./commands/status-command.ts";
+import { ListCommand } from "./commands/list-command.ts";
+import { FetchCommand } from "./commands/fetch-command.ts";
+import { ContinueCommand } from "./commands/continue-command.ts";
+import { NewCommand } from "./commands/new-command.ts";
+import { DeleteCommand } from "./commands/delete-command.ts";
+import { ExportCommand } from "./commands/export-command.ts";
+import { ExportAllCommand } from "./commands/export-all-command.ts";
+import { InstallBrowserCommand } from "./commands/install-browser-command.ts";
+import { InstallSkillsCommand } from "./commands/install-skills-command.ts";
+
+export interface CliCommandContext {
+  verbose: boolean;
+  mediator: Mediator;
+  profileAuthManager: ProfileAuthManager;
+}
+
+export interface CliCommand {
+  readonly name: string;
+  readonly description: string;
+  execute(args: string[], context: CliCommandContext): Promise<void>;
+}
+
+export class CommandRegistry {
+  private handlers = new Map<string, CliCommand>();
+
+  register(commandName: string, handler: CliCommand): void {
+    if (this.handlers.has(commandName)) {
+      throw new Error(`Command already registered: ${commandName}`);
+    }
+    this.handlers.set(commandName, handler);
+  }
+
+  getHandler(commandName: string): CliCommand | undefined {
+    return this.handlers.get(commandName);
+  }
+
+  has(commandName: string): boolean {
+    return this.handlers.has(commandName);
+  }
+
+  getRegisteredNames(): string[] {
+    return [...this.handlers.keys()];
+  }
+
+  registerAllCommands(): void {
+    const authCommand = new AuthCommand();
+    this.register("auth", authCommand);
+    this.register("login", authCommand);
+    this.register("profile", new ProfileCommand());
+    this.register("status", new StatusCommand());
+    this.register("list", new ListCommand());
+    this.register("fetch", new FetchCommand());
+    this.register("continue", new ContinueCommand());
+    this.register("new", new NewCommand());
+    this.register("delete", new DeleteCommand());
+    this.register("export", new ExportCommand());
+    this.register("export-all", new ExportAllCommand());
+    this.register("install-browser", new InstallBrowserCommand());
+    this.register("install-skills", new InstallSkillsCommand());
+  }
+}

package/src/cli/commands/install-skills-command.ts

@@ -0,0 +1,35 @@
+import chalk from "chalk";
+import type { CliCommand, CliCommandContext } from "../command-registry.ts";
+import { Logger } from "../../infrastructure/logger.ts";
+import { InstallSkillsService, SkillsInstallError } from "../../services/skills-service.ts";
+
+export class InstallSkillsCommand implements CliCommand {
+  readonly name = "install-skills";
+  readonly description = "Install GemiTerm opencode skills from expert-vision-software/opencode-gemiterm-skills";
+
+  async execute(_args: string[], _context: CliCommandContext): Promise<void> {
+    const logger = new Logger("install-skills-command");
+    logger.debug("Executing install-skills command");
+    const service = new InstallSkillsService({ logger });
+
+    console.log(chalk.dim("Installing GemiTerm opencode skills..."));
+
+    try {
+      const output = await service.install();
+      if (output) {
+        console.log(output);
+      }
+      console.log(chalk.green("Skills installed successfully."));
+    } catch (error) {
+      if (error instanceof SkillsInstallError) {
+        logger.error(error.message);
+        if (error.cause) {
+          logger.error(`Cause: ${error.cause.message}`);
+        }
+        console.error(chalk.red("Failed to install skills."));
+        process.exit(1);
+      }
+      throw error;
+    }
+  }
+}

package/src/cli/index.ts

@@ -3,13 +3,13 @@
 import { CommandRegistry } from "./command-registry.ts";
 import { Logger } from "../infrastructure/logger.ts";
 import { Mediator } from "../core/mediator.ts";
-import { showHelp } from "./commands/help.ts";
 import { GeminiClientService } from "../services/gemini-client-wrapper.ts";
 import { CookieStorageService } from "../services/cookie-storage-service.ts";
 import { ProfileAuthManager } from "../services/profile-auth-manager.ts";
 import { CookieStorage, ProfileManager } from "../infrastructure/storage.ts";
-import { getDefaultProfileName, listProfiles, ensureConfigDir } from "../infrastructure/config.ts";
+import { getDefaultProfileName, listProfiles } from "../infrastructure/config.ts";
 import { getPackageJson } from "../infrastructure/path-utils.ts";
+import { parseGlobalArgs, printVersion, printHelp } from "../infrastructure/cli-parser.ts";
 import { AuthenticationError } from "../core/errors.ts";
 import {
   AuthenticateCommandHandler,
@@ -30,39 +30,6 @@ import {
 
 const pkg = getPackageJson(import.meta.url);
 
-interface GlobalFlags {
-  verbose: boolean;
-  version: boolean;
-  help: boolean;
-}
-
-function parseGlobalFlags(args: string[]): { flags: GlobalFlags; remaining: string[] } {
-  const flags: GlobalFlags = {
-    verbose: process.env.GEMITERM_VERBOSE === "true",
-    version: false,
-    help: false,
-  };
-  const remaining: string[] = [];
-
-  for (const arg of args) {
-    if (arg === "--verbose" || arg === "-v") {
-      flags.verbose = true;
-    } else if (arg === "--version") {
-      flags.version = true;
-    } else if (arg === "--help" || arg === "-h") {
-      if (remaining.length === 0) {
-        flags.help = true;
-      } else {
-        remaining.push(arg);
-      }
-    } else {
-      remaining.push(arg);
-    }
-  }
-
-  return { flags, remaining };
-}
-
 async function setupMediator(mediator: Mediator): Promise<ProfileAuthManager> {
   const logger = new Logger("mediator");
   const cookieStorage = new CookieStorage();
@@ -159,31 +126,39 @@ async function setupMediator(mediator: Mediator): Promise<ProfileAuthManager> {
 async function main(): Promise<void> {
   const args = process.argv.slice(2);
   const logger = new Logger("cli");
-  const { flags, remaining } = parseGlobalFlags(args);
 
-  if (flags.verbose) {
+  let flags: ReturnType<typeof parseGlobalArgs>["flags"];
+  let subcommand: string | null;
+  let subcommandArgs: string[];
+  try {
+    ({ flags, subcommand, subcommandArgs } = parseGlobalArgs(args));
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(message);
+    process.exit(1);
+  }
+
+  const verbose = flags.verbose || process.env.GEMITERM_VERBOSE === "true";
+  if (verbose) {
     Logger.setVerbose(true);
   }
 
   if (flags.version) {
-    console.log(`gemiterm v${pkg.version}`);
+    printVersion(pkg.version);
     process.exit(0);
   }
 
   const registry = new CommandRegistry();
   registry.registerAllCommands();
 
-  if (remaining.length === 0) {
-    showHelp(registry);
+  if (!subcommand) {
+    printHelp(registry);
     process.exit(0);
   }
 
   const mediator = new Mediator();
   const profileAuthManager = await setupMediator(mediator);
 
-  const subcommand = remaining[0];
-  const subcommandArgs = remaining.slice(1);
-
   const handler = registry.getHandler(subcommand);
   if (!handler) {
     const known = registry.getRegisteredNames();
@@ -198,7 +173,7 @@ async function main(): Promise<void> {
   }
 
   try {
-    await handler.execute(subcommandArgs, { verbose: flags.verbose, mediator, profileAuthManager });
+    await handler.execute(subcommandArgs, { verbose, mediator, profileAuthManager });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     logger.error(`Command '${subcommand}' failed: ${message}`);

package/src/infrastructure/cli-parser.ts

@@ -0,0 +1,77 @@
+import { Command, CommanderError } from "commander";
+import type { CommandRegistry } from "../cli/command-registry.ts";
+import { showHelp } from "../cli/commands/help.ts";
+
+export interface ParsedFlags {
+  verbose: boolean;
+  version: boolean;
+  help: boolean;
+}
+
+export interface ParsedArgs {
+  flags: ParsedFlags;
+  subcommand: string | null;
+  subcommandArgs: string[];
+}
+
+function splitAtFirstNonFlag(argv: string[]): { pre: string[]; post: string[] } {
+  const pre: string[] = [];
+  const post: string[] = [];
+  let found = false;
+  for (const arg of argv) {
+    if (!found && !arg.startsWith("-")) {
+      found = true;
+      post.push(arg);
+      continue;
+    }
+    if (found) {
+      post.push(arg);
+    } else {
+      pre.push(arg);
+    }
+  }
+  return { pre, post };
+}
+
+export function parseGlobalArgs(argv: string[]): ParsedArgs {
+  const { pre, post } = splitAtFirstNonFlag(argv);
+  const subcommand = post[0] ?? null;
+  const subcommandArgs = post.slice(1);
+
+  const program = new Command();
+  program
+    .exitOverride()
+    .allowUnknownOption(false)
+    .allowExcessArguments(true)
+    .helpOption(false)
+    .configureOutput({ writeErr: () => {} })
+    .option("-v, --verbose", "enable verbose output")
+    .option("--version", "show version number")
+    .option("-h, --help", "show help");
+
+  try {
+    program.parse(pre, { from: "user" });
+  } catch (error) {
+    if (error instanceof CommanderError) {
+      throw new Error("gemiterm: " + error.message);
+    }
+    throw error;
+  }
+
+  const opts = program.opts<{ verbose?: boolean; version?: boolean; help?: boolean }>();
+  const flags: ParsedFlags = {
+    verbose: Boolean(opts.verbose),
+    version: Boolean(opts.version),
+    help: Boolean(opts.help),
+  };
+
+  return { flags, subcommand, subcommandArgs };
+}
+
+export function printVersion(pkgVersion: string): void {
+  console.log(`gemiterm v${pkgVersion}`);
+}
+
+export function printHelp(registry: CommandRegistry): void {
+  showHelp(registry);
+}

package/src/services/skills-cli-driver.ts

@@ -0,0 +1,58 @@
+import { Logger } from "../infrastructure/logger.ts";
+
+export class SkillsCliError extends Error {
+  constructor(command: string, exitCode: number, stderr: string) {
+    super(`skills '${command}' exited with code ${exitCode}: ${stderr}`);
+    this.name = "SkillsCliError";
+  }
+}
+
+export interface SkillsRunnerResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+export interface SkillsRunner {
+  run(args: string[]): Promise<SkillsRunnerResult>;
+}
+
+export class BunSkillsRunner implements SkillsRunner {
+  async run(args: string[]): Promise<SkillsRunnerResult> {
+    const proc = Bun.spawn(["npx", "skills", ...args], {
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "ignore",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+      proc.exited,
+    ]);
+    return { exitCode: exitCode ?? -1, stdout: stdout.trim(), stderr: stderr.trim() };
+  }
+}
+
+export interface SkillsCliDriverOptions {
+  logger?: Logger;
+  runner?: SkillsRunner;
+}
+
+export class SkillsCliDriver {
+  private readonly logger: Logger;
+  private readonly runner: SkillsRunner;
+
+  constructor(opts: SkillsCliDriverOptions = {}) {
+    this.logger = opts.logger ?? new Logger("skills-cli-driver");
+    this.runner = opts.runner ?? new BunSkillsRunner();
+  }
+
+  async run(args: string[]): Promise<string> {
+    this.logger.debug(`Running: npx skills ${args.join(" ")}`);
+    const result = await this.runner.run(args);
+    if (result.exitCode !== 0) {
+      throw new SkillsCliError(args.join(" "), result.exitCode, result.stderr);
+    }
+    return result.stdout;
+  }
+}

package/src/services/skills-service.ts

@@ -0,0 +1,52 @@
+import { Logger } from "../infrastructure/logger.ts";
+import { SkillsCliDriver, SkillsCliDriverOptions, SkillsCliError } from "./skills-cli-driver.ts";
+
+export class SkillsInstallError extends Error {
+  constructor(message: string, public readonly cause?: Error) {
+    super(message);
+    this.name = "SkillsInstallError";
+  }
+}
+
+export interface InstallSkillsServiceOptions {
+  logger?: Logger;
+  driver?: SkillsCliDriver;
+  repo?: string;
+  skills?: string[];
+}
+
+export class InstallSkillsService {
+  private readonly logger: Logger;
+  private readonly driver: SkillsCliDriver;
+  private readonly repo: string;
+  private readonly skills: string[];
+
+  constructor(opts: InstallSkillsServiceOptions = {}) {
+    this.logger = opts.logger ?? new Logger("install-skills-service");
+    this.repo = opts.repo ?? "expert-vision-software/opencode-gemiterm-skills";
+    this.skills = opts.skills ?? ["gemiterm", "debate-with-gemini"];
+    this.driver = opts.driver ?? new SkillsCliDriver({ logger: this.logger });
+  }
+
+  async install(): Promise<string> {
+    this.logger.info(`Installing skills from ${this.repo}: ${this.skills.join(", ")}`);
+    const args = ["add", this.repo];
+    for (const skill of this.skills) {
+      args.push("--skill", skill);
+    }
+
+    try {
+      const output = await this.driver.run(args);
+      this.logger.info(`Skills installed successfully: ${output}`);
+      return output;
+    } catch (error) {
+      if (error instanceof SkillsCliError) {
+        throw new SkillsInstallError(error.message, error);
+      }
+      throw new SkillsInstallError(
+        `Failed to install skills: ${error instanceof Error ? error.message : String(error)}`,
+        error instanceof Error ? error : undefined,
+      );
+    }
+  }
+}

package/.env

@@ -1,2 +0,0 @@
-GEMITERM_CONFIG_DIR=./.gemiterm
-GEMITERM_VERBOSE=true

package/.github/workflows/manual-release.yml

@@ -1,34 +0,0 @@
-name: Manual Release
-
-on:
-  workflow_dispatch:
-    inputs:
-      ref:
-        description: 'Commit hash, branch, or tag to build'
-        required: true
-        type: string
-      draft:
-        description: 'Create a draft release (recommended for testing)'
-        required: true
-        type: boolean
-        default: true
-      pre_release:
-        description: 'Mark as pre-release'
-        required: true
-        type: boolean
-        default: true
-      publish:
-        description: 'Publish to npm (DANGEROUS — only enable if you mean it)'
-        required: true
-        type: boolean
-        default: false
-
-jobs:
-  build:
-    uses: ./.github/workflows/release.yml
-    with:
-      ref: ${{ inputs.ref }}
-      tag_name: manual-${{ inputs.ref }}-${{ github.run_id }}
-      publish: ${{ inputs.publish }}
-      draft: ${{ inputs.draft }}
-      prerelease: ${{ inputs.pre_release }}