@sunasteriskrnd/takumi 1.0.0-dev.1 → 1.0.0-dev.2

package/README.md

@@ -33,12 +33,18 @@ Verify: `tkm --version`
 
 ```bash
 tkm --help                      # All commands
+tkm auth login                  # One-time login (default install path)
 tkm new                         # Create new project (interactive)
 tkm new --kit engineer          # Create with specific kit
 tkm init                        # Initialize/update in current project
 tkm init -g -y                  # Global install, non-interactive
 ```
 
+The default `tkm init` / `new` / `versions` flows download releases
+through the authenticated Takumi server (no `gh` CLI required). Run
+`tkm auth login` once before the first install. The legacy GitHub
+flow is still available via `--use-gh` for archived tags.
+
 ### Create New Project
 
 ```bash

package/dist/index.js

@@ -11361,7 +11361,8 @@ var init_commands = __esm(() => {
   VersionCommandOptionsSchema = exports_external.object({
     kit: KitType.optional(),
     limit: exports_external.number().optional(),
-    all: exports_external.boolean().optional()
+    all: exports_external.boolean().optional(),
+    useGh: exports_external.boolean().default(false)
   }).merge(GlobalOutputOptionsSchema);
   UninstallCommandOptionsSchema = exports_external.object({
     yes: exports_external.boolean().default(false),
@@ -40841,6 +40842,49 @@ var init_agents_command_help = __esm(() => {
   };
 });
 
+// src/domains/help/commands/auth-command-help.ts
+var authCommandHelp;
+var init_auth_command_help = __esm(() => {
+  authCommandHelp = {
+    name: "auth",
+    description: "Sign in/out and check Takumi session (login|logout|status)",
+    usage: "tkm auth <login|logout|status>",
+    examples: [
+      {
+        command: "tkm auth login",
+        description: "Sign in via browser (Supabase OAuth, PKCE-localhost flow)"
+      },
+      {
+        command: "tkm auth status",
+        description: "Show signed-in identity and token expiry"
+      },
+      {
+        command: "tkm auth logout",
+        description: "Clear local Takumi session"
+      }
+    ],
+    optionGroups: [
+      {
+        title: "Actions",
+        options: [
+          {
+            flags: "login",
+            description: "Open browser, complete PKCE-localhost flow, store session"
+          },
+          {
+            flags: "status",
+            description: "Print signed-in email and token expiry; refreshes if needed"
+          },
+          {
+            flags: "logout",
+            description: "Remove the local session token"
+          }
+        ]
+      }
+    ]
+  };
+});
+
 // src/domains/help/commands/commands-command-help.ts
 var commandsCommandHelp;
 var init_commands_command_help = __esm(() => {
@@ -41153,6 +41197,7 @@ var init_commands2 = __esm(() => {
   init_projects_command_help();
   init_setup_command_help();
   init_agents_command_help();
+  init_auth_command_help();
   init_commands_command_help();
   init_content_command_help();
   init_migrate_command_help();
@@ -41181,6 +41226,7 @@ var init_help_commands = __esm(() => {
     uninstall: uninstallCommandHelp,
     skills: skillsCommandHelp,
     agents: agentsCommandHelp,
+    auth: authCommandHelp,
     commands: commandsCommandHelp,
     migrate: migrateCommandHelp,
     watch: watchCommandHelp
@@ -53916,9 +53962,119 @@ async function doctorCommand(options2 = {}) {
 }
 
 // src/domains/sync/config-version-checker.ts
+init_auth_client();
 import { mkdir as mkdir10, readFile as readFile16, unlink as unlink9, writeFile as writeFile14 } from "node:fs/promises";
 import { join as join34 } from "node:path";
 
+// src/domains/installation/release-source.ts
+init_auth_client();
+
+// src/types/release-entry.ts
+init_zod();
+var ReleaseEntrySchema = exports_external.object({
+  tag: exports_external.string(),
+  version: exports_external.string(),
+  prerelease: exports_external.boolean(),
+  published_at: exports_external.string(),
+  archive: exports_external.string()
+}).transform((raw) => ({
+  tag: raw.tag,
+  version: raw.version,
+  prerelease: raw.prerelease,
+  publishedAt: raw.published_at,
+  archive: raw.archive
+}));
+var ReleaseListResponseSchema = exports_external.object({
+  channel: exports_external.enum(["stable", "beta"]),
+  updated_at: exports_external.string().nullable().optional(),
+  versions: exports_external.array(ReleaseEntrySchema)
+});
+
+class NotInIndexError extends Error {
+  tag;
+  constructor(tag) {
+    super(`Tag ${tag} not in Worker index. For archived versions use --use-gh.`);
+    this.name = "NotInIndexError";
+    this.tag = tag;
+  }
+}
+
+// src/domains/installation/release-source.ts
+function assetNameFor(kit) {
+  return `takumi-${kit}-package.zip`;
+}
+
+class WorkerSource {
+  serverUrl;
+  kit;
+  tokenProvider;
+  kind = "worker";
+  constructor(serverUrl, kit = "engineer", tokenProvider = getValidToken) {
+    this.serverUrl = serverUrl;
+    this.kit = kit;
+    this.tokenProvider = tokenProvider;
+  }
+  async authHeaders() {
+    const token = await this.tokenProvider();
+    if (!token)
+      throw new NotLoggedInError;
+    return {
+      Authorization: `Bearer ${token}`,
+      "X-TKM-Client": "takumi-cli/release-source"
+    };
+  }
+  async fetchLatest(beta) {
+    const url = `${this.serverUrl}/api/packages/${encodeURIComponent(this.kit)}/releases/latest${beta ? "?beta=1" : ""}`;
+    const headers = await this.authHeaders();
+    const res = await fetch(url, { headers });
+    if (res.status === 401)
+      throw new NotLoggedInError;
+    if (!res.ok) {
+      throw new Error(`Worker source: GET ${url} failed (HTTP ${res.status})`);
+    }
+    return ReleaseEntrySchema.parse(await res.json());
+  }
+  async fetchReleaseList(beta) {
+    const url = `${this.serverUrl}/api/packages/${encodeURIComponent(this.kit)}/releases${beta ? "?beta=1" : ""}`;
+    const headers = await this.authHeaders();
+    const res = await fetch(url, { headers });
+    if (res.status === 401)
+      throw new NotLoggedInError;
+    if (!res.ok) {
+      throw new Error(`Worker source: GET ${url} failed (HTTP ${res.status})`);
+    }
+    const parsed = ReleaseListResponseSchema.parse(await res.json());
+    return parsed.versions;
+  }
+  async fetchByTag(tag) {
+    const url = `${this.serverUrl}/api/packages/${encodeURIComponent(this.kit)}/releases/${encodeURIComponent(tag)}`;
+    const headers = await this.authHeaders();
+    const res = await fetch(url, { headers });
+    if (res.status === 401)
+      throw new NotLoggedInError;
+    if (res.status === 404)
+      throw new NotInIndexError(tag);
+    if (!res.ok) {
+      throw new Error(`Worker source: GET ${url} failed (HTTP ${res.status})`);
+    }
+    return ReleaseEntrySchema.parse(await res.json());
+  }
+  async fetchAsset(tag, asset) {
+    const url = `${this.serverUrl}/api/packages/${encodeURIComponent(this.kit)}/releases/${encodeURIComponent(tag)}/${encodeURIComponent(asset)}`;
+    const headers = await this.authHeaders();
+    const res = await fetch(url, { headers });
+    if (res.status === 401)
+      throw new NotLoggedInError;
+    if (res.status === 404) {
+      throw new Error(`Asset not found: ${this.kit}/${tag}/${asset}`);
+    }
+    if (!res.ok) {
+      throw new Error(`Worker source: GET ${url} failed (HTTP ${res.status})`);
+    }
+    return res;
+  }
+}
+
 // src/domains/versioning/checking/version-utils.ts
 var import_compare_versions2 = __toESM(require_umd(), 1);
 function isUpdateCheckDisabled() {
@@ -53968,7 +54124,6 @@ function isNewerVersion(currentVersion, latestVersion) {
 // src/domains/sync/config-version-checker.ts
 init_logger();
 init_path_resolver();
-init_takumi_constants();
 var CACHE_TTL_HOURS = 24;
 var DEFAULT_CACHE_TTL_MS = CACHE_TTL_HOURS * 60 * 60 * 1000;
 var MIN_CACHE_TTL_MS = 60 * 1000;
@@ -53995,11 +54150,7 @@ function parseCacheTtl() {
   return ttlMs;
 }
 var CACHE_TTL_MS = parseCacheTtl();
-var GITHUB_API_TIMEOUT_MS = 1e4;
 var CACHE_FILENAME = "config-update-cache.json";
-var KIT_REPOS = {
-  engineer: { owner: "sun-asterisk-internal", repo: "agent-kit" }
-};
 
 class ConfigVersionChecker {
   static getCacheFilePath(kitType, global3) {
@@ -54030,61 +54181,30 @@ class ConfigVersionChecker {
       logger.debug(`Cache write failed: ${error instanceof Error ? error.message : "Unknown error"}`);
     }
   }
-  static async fetchLatestVersion(kitType, etag) {
-    const repoInfo = KIT_REPOS[kitType];
-    if (!repoInfo)
-      return null;
-    const url = `https://api.github.com/repos/${repoInfo.owner}/${repoInfo.repo}/releases/latest`;
+  static async fetchLatestVersion(kitType) {
     const maxRetries = 3;
     const baseBackoff = 1000;
     for (let attempt = 0;attempt < maxRetries; attempt++) {
       try {
-        const headers = {
-          Accept: "application/vnd.github.v3+json",
-          "User-Agent": getCliUserAgent()
-        };
-        const githubToken = process.env.GITHUB_TOKEN;
-        if (githubToken) {
-          headers.Authorization = `Bearer ${githubToken}`;
-        }
-        if (etag) {
-          headers["If-None-Match"] = etag;
-        }
-        const response = await fetch(url, {
-          headers,
-          signal: AbortSignal.timeout(GITHUB_API_TIMEOUT_MS)
-        });
-        const remaining = response.headers.get("x-ratelimit-remaining");
-        if (remaining && Number.parseInt(remaining, 10) < 10) {
-          logger.warning(`GitHub API rate limit low: ${remaining} remaining. Set GITHUB_TOKEN env var for higher limits (5000/hr vs 60/hr).`);
-        }
-        if (response.status === 304) {
-          return "not-modified";
-        }
-        if (!response.ok) {
-          if (response.status === 403) {
-            logger.warning("GitHub API rate limit exceeded. " + "Set GITHUB_TOKEN env var for higher limits (5000/hr vs 60/hr).");
-            return null;
-          }
-          throw new Error(`GitHub API returned ${response.status}`);
-        }
-        const data = await response.json();
-        const version3 = data.tag_name?.replace(/^v/, "") || null;
+        const worker = new WorkerSource(getServerUrl(), kitType);
+        const entry = await worker.fetchLatest();
+        const version3 = entry.version.replace(/^v/, "");
         if (!version3 || version3.length > 256) {
-          logger.debug(`Invalid version format from GitHub: ${data.tag_name}`);
+          logger.debug(`Invalid version format from Worker: ${entry.version}`);
           return null;
         }
         const semverParts = version3.split(/[-+]/);
         const coreParts = semverParts[0].split(".");
         if (coreParts.length !== 3 || !coreParts.every((p) => /^\d+$/.test(p))) {
-          logger.debug(`Invalid version format from GitHub: ${data.tag_name}`);
+          logger.debug(`Invalid version format from Worker: ${entry.version}`);
           return null;
         }
-        return {
-          version: version3,
-          etag: response.headers.get("etag") || undefined
-        };
+        return { version: version3 };
       } catch (error) {
+        if (error instanceof NotLoggedInError) {
+          logger.debug("Skipping update check (not logged in)");
+          return null;
+        }
         const isLastAttempt = attempt === maxRetries - 1;
         if (isLastAttempt) {
           logger.debug(`Version check failed after ${maxRetries} attempts: ${error}`);
@@ -54109,25 +54229,11 @@ class ConfigVersionChecker {
         fromCache: true
       };
     }
-    const result = await ConfigVersionChecker.fetchLatestVersion(kitType, cache?.etag);
-    if (result === "not-modified" && cache) {
-      await ConfigVersionChecker.saveCache(kitType, global3, {
-        ...cache,
-        lastCheck: now
-      });
-      const hasUpdates = isNewerVersion(normalizedCurrent, cache.latestVersion);
-      return {
-        hasUpdates,
-        currentVersion: normalizedCurrent,
-        latestVersion: cache.latestVersion,
-        fromCache: false
-      };
-    }
-    if (result && result !== "not-modified") {
+    const result = await ConfigVersionChecker.fetchLatestVersion(kitType);
+    if (result) {
       await ConfigVersionChecker.saveCache(kitType, global3, {
         lastCheck: now,
-        latestVersion: result.version,
-        etag: result.etag
+        latestVersion: result.version
       });
       const hasUpdates = isNewerVersion(normalizedCurrent, result.version);
       return {
@@ -56222,7 +56328,38 @@ async function getDirectory(defaultDir = ".") {
   return trimmed.length > 0 ? trimmed : defaultDir;
 }
 // src/domains/versioning/version-selector.ts
+init_auth_client();
 init_github_client();
+
+// src/domains/installation/release-entry-adapter.ts
+function githubReleaseToEntry(release, kit = "engineer") {
+  const expected = assetNameFor(kit);
+  const expectedAsset = release.assets.find((a3) => a3.name === expected);
+  const fallback2 = release.assets[0];
+  const archive = expectedAsset?.name ?? fallback2?.name ?? expected;
+  return {
+    tag: release.tag_name,
+    version: release.tag_name.replace(/^v/, ""),
+    prerelease: release.prerelease,
+    publishedAt: release.published_at ?? "",
+    archive
+  };
+}
+function releaseEntryToGitHubRelease(entry, kit) {
+  return {
+    id: 0,
+    tag_name: entry.tag,
+    name: entry.tag,
+    draft: false,
+    prerelease: entry.prerelease,
+    published_at: entry.publishedAt || undefined,
+    tarball_url: `https://github.com/${kit.owner}/${kit.repo}/archive/refs/tags/${entry.tag}.tar.gz`,
+    zipball_url: `https://github.com/${kit.owner}/${kit.repo}/archive/refs/tags/${entry.tag}.zip`,
+    assets: []
+  };
+}
+
+// src/domains/versioning/version-selector.ts
 init_logger();
 init_dist2();
 init_release_filter();
@@ -56553,6 +56690,17 @@ class VersionSelector {
   constructor(githubClient) {
     this.githubClient = githubClient ?? new GitHubClient;
   }
+  async fetchFromWorker(kit, includePrereleases) {
+    const worker = new WorkerSource(getServerUrl(), kit.id);
+    const entries = await worker.fetchReleaseList(includePrereleases);
+    const releases = entries.map((entry, idx) => ({
+      ...releaseEntryToGitHubRelease(entry, kit),
+      id: entries.length - idx
+    }));
+    return ReleaseFilter.processReleases(releases, {
+      includePrereleases
+    });
+  }
   async selectVersion(options2) {
     const {
       kit,
@@ -56561,18 +56709,24 @@ class VersionSelector {
       defaultValue,
       allowManualEntry = false,
       forceRefresh = false,
-      currentVersion = null
+      currentVersion = null,
+      useGh = false
     } = options2;
     try {
       const loadingSpinner = de();
       loadingSpinner.start(`Fetching versions for ${import_picocolors18.default.bold(kit.name)}...`);
-      let releases = await this.githubClient.listReleasesWithCache(kit, {
-        limit: limit * 2,
-        includePrereleases,
-        forceRefresh
-      });
-      if (includePrereleases) {
-        releases = await this.injectLatestStable(kit, releases, forceRefresh);
+      let releases;
+      if (useGh) {
+        releases = await this.githubClient.listReleasesWithCache(kit, {
+          limit: limit * 2,
+          includePrereleases,
+          forceRefresh
+        });
+        if (includePrereleases) {
+          releases = await this.injectLatestStable(kit, releases, forceRefresh);
+        }
+      } else {
+        releases = await this.fetchFromWorker(kit, includePrereleases);
       }
       loadingSpinner.stop();
       if (releases.length === 0) {
@@ -56604,17 +56758,19 @@ class VersionSelector {
       return releases;
     }
   }
-  async getLatestVersion(kit, includePrereleases = false, forceRefresh = false) {
+  async getLatestVersion(kit, includePrereleases = false, forceRefresh = false, useGh = false) {
     try {
-      const releases = await this.githubClient.listReleasesWithCache(kit, {
-        limit: 5,
-        includePrereleases,
-        forceRefresh
-      });
-      if (releases.length === 0) {
-        return null;
+      if (useGh) {
+        const releases = await this.githubClient.listReleasesWithCache(kit, {
+          limit: 5,
+          includePrereleases,
+          forceRefresh
+        });
+        return releases[0]?.tag_name ?? null;
       }
-      return releases[0].tag_name;
+      const worker = new WorkerSource(getServerUrl(), kit.id);
+      const entry = await worker.fetchLatest(includePrereleases);
+      return entry.tag;
     } catch (error) {
       logger.error(`Failed to get latest version for ${kit.name}: ${error}`);
       return null;
@@ -61162,58 +61318,6 @@ Solutions:
   }
 }
 
-// src/domains/installation/release-source.ts
-init_auth_client();
-function assetNameFor(kit) {
-  return `takumi-${kit}-package.zip`;
-}
-
-class WorkerSource {
-  serverUrl;
-  kit;
-  tokenProvider;
-  kind = "worker";
-  constructor(serverUrl, kit = "engineer", tokenProvider = getValidToken) {
-    this.serverUrl = serverUrl;
-    this.kit = kit;
-    this.tokenProvider = tokenProvider;
-  }
-  async authHeaders() {
-    const token = await this.tokenProvider();
-    if (!token)
-      throw new NotLoggedInError;
-    return {
-      Authorization: `Bearer ${token}`,
-      "X-TKM-Client": "takumi-cli/release-source"
-    };
-  }
-  async fetchLatest() {
-    const url = `${this.serverUrl}/api/packages/${encodeURIComponent(this.kit)}/releases/latest`;
-    const headers = await this.authHeaders();
-    const res = await fetch(url, { headers });
-    if (res.status === 401)
-      throw new NotLoggedInError;
-    if (!res.ok) {
-      throw new Error(`Worker source: GET ${url} failed (HTTP ${res.status})`);
-    }
-    return await res.json();
-  }
-  async fetchAsset(tag, asset) {
-    const url = `${this.serverUrl}/api/packages/${encodeURIComponent(this.kit)}/releases/${encodeURIComponent(tag)}/${encodeURIComponent(asset)}`;
-    const headers = await this.authHeaders();
-    const res = await fetch(url, { headers });
-    if (res.status === 401)
-      throw new NotLoggedInError;
-    if (res.status === 404) {
-      throw new Error(`Asset not found: ${this.kit}/${tag}/${asset}`);
-    }
-    if (!res.ok) {
-      throw new Error(`Worker source: GET ${url} failed (HTTP ${res.status})`);
-    }
-    return res;
-  }
-}
-
 // src/domains/installation/download-extractor.ts
 init_logger();
 init_output_manager();
@@ -68039,6 +68143,7 @@ async function handlePostInstall(ctx) {
   };
 }
 // src/commands/init/phases/selection-handler.ts
+init_auth_client();
 import { mkdir as mkdir24 } from "node:fs/promises";
 import { join as join81, resolve as resolve13 } from "node:path";
 init_github_client();
@@ -68379,9 +68484,16 @@ async function handleSelection(ctx) {
     return ctx;
   if (isSyncContext(ctx) && ctx.kitType && ctx.resolvedDir && ctx.selectedVersion) {
     const kit2 = AVAILABLE_KITS[ctx.kitType];
-    const github2 = new GitHubClient;
     logger.info(`Sync mode: using ${kit2.name} version ${ctx.selectedVersion}`);
-    const release2 = await github2.getReleaseByTag(kit2, ctx.selectedVersion);
+    let release2;
+    if (ctx.options.useGh) {
+      const github2 = new GitHubClient;
+      release2 = await github2.getReleaseByTag(kit2, ctx.selectedVersion);
+    } else {
+      const worker = new WorkerSource(getServerUrl(), ctx.kitType);
+      const entry = await worker.fetchByTag(ctx.selectedVersion);
+      release2 = releaseEntryToGitHubRelease(entry, kit2);
+    }
     return {
       ...ctx,
       kit: kit2,
@@ -68404,7 +68516,8 @@ async function handleSelection(ctx) {
   }
   const config = await ConfigManager.get();
   let accessibleKits;
-  if (!ctx.options.useGit && !ctx.options.kitPath && !ctx.options.archive) {
+  const useLegacyGh = !!(ctx.options.useGh || ctx.options.useGit);
+  if (useLegacyGh && !ctx.options.kitPath && !ctx.options.archive) {
     const preflight = await runPreflightChecks();
     if (!preflight.success) {
       for (const line of preflight.errorLines) {
@@ -68560,7 +68673,7 @@ async function handleSelection(ctx) {
     }
   }
   const isOfflineMode = !!(ctx.options.kitPath || ctx.options.archive);
-  const github = isOfflineMode ? null : new GitHubClient;
+  const github = !isOfflineMode && useLegacyGh ? new GitHubClient : null;
   let selectedVersion = ctx.options.release;
   if (!selectedVersion && ctx.isNonInteractive && !ctx.options.yes && !isOfflineMode) {
     throw new Error("Non-interactive mode requires either: --release <tag> OR --yes (uses latest)");
@@ -68587,7 +68700,8 @@ async function handleSelection(ctx) {
         limit: 10,
         allowManualEntry: true,
         forceRefresh: ctx.options.refresh,
-        currentVersion
+        currentVersion,
+        useGh: useLegacyGh
       });
       if (!versionResult) {
         logger.warning("Version selection cancelled by user");
@@ -68634,6 +68748,24 @@ async function handleSelection(ctx) {
     } else {
       logger.success(`Found: ${release.tag_name}`);
     }
+  } else if (selectedVersion) {
+    const worker = new WorkerSource(getServerUrl(), kitType);
+    const entry = await worker.fetchByTag(selectedVersion);
+    release = releaseEntryToGitHubRelease(entry, kit);
+  } else {
+    if (ctx.options.beta) {
+      logger.info("Fetching latest beta release...");
+    } else {
+      logger.info("Fetching latest release...");
+    }
+    const worker = new WorkerSource(getServerUrl(), kitType);
+    const entry = await worker.fetchLatest(ctx.options.beta);
+    release = releaseEntryToGitHubRelease(entry, kit);
+    if (release.prerelease) {
+      logger.success(`Found beta: ${release.tag_name}`);
+    } else {
+      logger.success(`Found: ${release.tag_name}`);
+    }
   }
   if (ctx.options.force && !ctx.options.yes) {
     logger.info("--force has no effect without --yes (the version-match skip only applies in non-interactive mode)");
@@ -72054,6 +72186,7 @@ init_output_manager();
 init_types2();
 
 // src/commands/new/phases/version-selection.ts
+init_auth_client();
 init_logger();
 async function selectVersion2(kit, options2, isNonInteractive2, prompts, github) {
   if (options2.kitPath || options2.archive) {
@@ -72076,6 +72209,7 @@ async function selectVersion2(kit, options2, isNonInteractive2, prompts, github)
   if (!selectedVersion && isNonInteractive2) {
     throw new Error("Interactive version selection unavailable in non-interactive mode. " + "Either: (1) use --release <tag> flag, or (2) set CI=false to enable interactive mode");
   }
+  const useLegacyGh = !!(options2.useGh || options2.useGit);
   if (!selectedVersion && !isNonInteractive2) {
     logger.info("Fetching available versions...");
     try {
@@ -72084,7 +72218,8 @@ async function selectVersion2(kit, options2, isNonInteractive2, prompts, github)
         includePrereleases: options2.beta,
         limit: 10,
         allowManualEntry: true,
-        forceRefresh: options2.refresh
+        forceRefresh: options2.refresh,
+        useGh: useLegacyGh
       });
       if (!versionResult) {
         logger.warning("Version selection cancelled by user");
@@ -72112,19 +72247,40 @@ async function selectVersion2(kit, options2, isNonInteractive2, prompts, github)
       assets: []
     };
     logger.verbose("Using git clone mode with tag", { tag: selectedVersion });
-  } else if (selectedVersion) {
-    release = await github.getReleaseByTag(kit, selectedVersion);
-  } else {
-    if (options2.beta) {
-      logger.info("Fetching latest beta release...");
+  } else if (options2.useGh && github) {
+    if (selectedVersion) {
+      release = await github.getReleaseByTag(kit, selectedVersion);
     } else {
-      logger.info("Fetching latest release...");
+      if (options2.beta) {
+        logger.info("Fetching latest beta release...");
+      } else {
+        logger.info("Fetching latest release...");
+      }
+      release = await github.getLatestRelease(kit, options2.beta);
+      if (release.prerelease) {
+        logger.success(`Found beta: ${release.tag_name}`);
+      } else {
+        logger.success(`Found: ${release.tag_name}`);
+      }
     }
-    release = await github.getLatestRelease(kit, options2.beta);
-    if (release.prerelease) {
-      logger.success(`Found beta: ${release.tag_name}`);
+  } else {
+    const worker = new WorkerSource(getServerUrl(), kit.id);
+    if (selectedVersion) {
+      const entry = await worker.fetchByTag(selectedVersion);
+      release = releaseEntryToGitHubRelease(entry, kit);
     } else {
-      logger.success(`Found: ${release.tag_name}`);
+      if (options2.beta) {
+        logger.info("Fetching latest beta release...");
+      } else {
+        logger.info("Fetching latest release...");
+      }
+      const entry = await worker.fetchLatest(options2.beta);
+      release = releaseEntryToGitHubRelease(entry, kit);
+      if (release.prerelease) {
+        logger.success(`Found beta: ${release.tag_name}`);
+      } else {
+        logger.success(`Found: ${release.tag_name}`);
+      }
     }
   }
   return {
@@ -72136,7 +72292,8 @@ async function selectVersion2(kit, options2, isNonInteractive2, prompts, github)
 // src/commands/new/phases/project-creation.ts
 async function projectCreation(kit, resolvedDir, validOptions, isNonInteractive2, prompts) {
   const kitConfig = AVAILABLE_KITS[kit];
-  const github = new GitHubClient;
+  const useLegacyGh = !!(validOptions.useGh || validOptions.useGit);
+  const github = useLegacyGh ? new GitHubClient : null;
   const versionResult = await selectVersion2(kitConfig, validOptions, isNonInteractive2, prompts, github);
   if (!versionResult) {
     return null;
@@ -73961,11 +74118,9 @@ async function handlePreflightCheck(ctx) {
   f2.step("Running preflight checks...");
   let hasIssues = false;
   if (!isGhInstalled()) {
-    f2.warning("GitHub CLI not installed. Install from https://cli.github.com/ then run 'gh auth login'.");
-    hasIssues = true;
+    f2.info("GitHub CLI not installed (optional — needed only for legacy `--use-gh` / `--use-git` flows).");
   } else if (!checkGhAuth()) {
-    f2.warning("GitHub CLI not authenticated. Run 'gh auth login' to authenticate with GitHub.");
-    hasIssues = true;
+    f2.info("GitHub CLI not authenticated (optional — needed only for legacy `--use-gh` / `--use-git` flows).");
   } else {
     f2.success("GitHub CLI: authenticated");
   }
@@ -75971,7 +76126,7 @@ var import_fs_extra37 = __toESM(require_lib(), 1);
 // package.json
 var package_default = {
   name: "@sunasteriskrnd/takumi",
-  version: "1.0.0-dev.1",
+  version: "1.0.0-dev.2",
   description: "CLI tool for bootstrapping and managing Takumi projects",
   type: "module",
   repository: {
@@ -76550,6 +76705,7 @@ Manual update: ${redactCommandForLog(updateCmd)}`;
 }
 
 // src/commands/version.ts
+init_auth_client();
 init_github_client();
 init_logger();
 init_types2();
@@ -76582,44 +76738,45 @@ ${import_picocolors35.default.bold(import_picocolors35.default.cyan(kitName))} -
     return;
   }
   for (const release of releases) {
-    const version3 = import_picocolors35.default.green(release.tag_name);
-    const name = release.name || "No title";
-    const publishedAt = formatRelativeTime(release.published_at);
-    const assetCount = release.assets.length;
-    const badges = [];
-    if (release.prerelease)
-      badges.push(import_picocolors35.default.yellow("[prerelease]"));
-    if (release.draft)
-      badges.push(import_picocolors35.default.gray("[draft]"));
-    const badgeStr = badges.length > 0 ? ` ${badges.join(" ")}` : "";
+    const version3 = import_picocolors35.default.green(release.tag);
+    const publishedAt = formatRelativeTime(release.publishedAt);
+    const badge = release.prerelease ? ` ${import_picocolors35.default.yellow("[prerelease]")}` : "";
     const versionPart = version3.padEnd(20);
-    const namePart = name.length > 40 ? `${name.slice(0, 37)}...` : name.padEnd(40);
     const timePart = import_picocolors35.default.dim(publishedAt.padEnd(20));
-    const assetPart = import_picocolors35.default.dim(`(${assetCount} ${assetCount === 1 ? "asset" : "assets"})`);
-    console.log(`  ${versionPart}  ${namePart}  ${timePart}  ${assetPart}${badgeStr}`);
+    console.log(`  ${versionPart}  ${timePart}${badge}`);
   }
   console.log(import_picocolors35.default.dim(`
 Showing ${releases.length} ${releases.length === 1 ? "release" : "releases"}`));
 }
+async function fetchReleasesForKit(kitType, options2) {
+  const kitConfig = AVAILABLE_KITS[kitType];
+  if (options2.useGh) {
+    const github = new GitHubClient;
+    const releases = await github.listReleases(kitConfig, options2.limit);
+    const filtered = options2.includePrereleases ? releases : releases.filter((r2) => !r2.draft && !r2.prerelease);
+    return filtered.map((r2) => githubReleaseToEntry(r2, kitType));
+  }
+  const worker = new WorkerSource(getServerUrl(), kitType);
+  const entries = await worker.fetchReleaseList(options2.includePrereleases);
+  return entries.slice(0, options2.limit);
+}
 async function versionCommand(options2) {
   const prompts2 = new PromptsManager;
   prompts2.intro("\uD83D\uDCE6 Takumi - Available Versions");
   try {
     const validOptions = VersionCommandOptionsSchema.parse(options2);
     const kitsToFetch = validOptions.kit ? [validOptions.kit] : Object.keys(AVAILABLE_KITS);
-    const github = new GitHubClient;
     const limit = validOptions.limit || 30;
+    const includePrereleases = !!validOptions.all;
     const releasePromises = kitsToFetch.map(async (kitType) => {
       const kitConfig = AVAILABLE_KITS[kitType];
       try {
-        const releases = await github.listReleases(kitConfig, limit);
-        const filteredReleases = validOptions.all ? releases : releases.filter((r2) => !r2.draft && !r2.prerelease);
-        return {
-          kitType,
-          kitConfig,
-          releases: filteredReleases,
-          error: null
-        };
+        const releases = await fetchReleasesForKit(kitType, {
+          includePrereleases,
+          limit,
+          useGh: validOptions.useGh
+        });
+        return { kitType, kitConfig, releases, error: null };
       } catch (error) {
         return {
           kitType,
@@ -78534,7 +78691,7 @@ function registerCommands(cli) {
       process.exit(1);
     }
   });
-  cli.command("versions", "List available versions of Takumi repositories").option("--kit <kit>", "Filter by specific kit (engineer)").option("--limit <limit>", "Number of releases to show (default: 30)").option("--all", "Show all releases including prereleases").action(async (options2) => {
+  cli.command("versions", "List available versions of Takumi repositories").option("--kit <kit>", "Filter by specific kit (engineer)").option("--limit <limit>", "Number of releases to show (default: 30)").option("--all", "Show the beta channel (prereleases only) instead of the stable channel. " + "On --use-gh, returns all release types interleaved.").option("--use-gh", "Use legacy GitHub release source (requires gh CLI)").action(async (options2) => {
     await versionCommand(options2);
   });
   cli.command("doctor", "Comprehensive health check for Takumi").option("--report", "Generate shareable diagnostic report").option("--fix", "Auto-fix all fixable issues").option("--check-only", "CI mode: no prompts, exit 1 on failures").option("--json", "Output JSON format").option("--full", "Include extended priority checks (slower)").action(async (options2) => {
@@ -78623,14 +78780,25 @@ function registerCommands(cli) {
     }
     await migrateCommand(options2);
   });
-  cli.command("auth login", "Sign in to Takumi via browser (Supabase OAuth)").action(async () => {
-    await login();
-  });
-  cli.command("auth logout", "Clear local Takumi session").action(async () => {
-    await logout();
-  });
-  cli.command("auth status", "Show signed-in identity and token expiry").action(async () => {
-    await status();
+  cli.command("auth [action]", "Sign in/out and check Takumi session (login|logout|status)").action(async (action) => {
+    switch (action) {
+      case "login":
+        await login();
+        break;
+      case "logout":
+        await logout();
+        break;
+      case "status":
+        await status();
+        break;
+      case undefined:
+        console.error("Usage: tkm auth <login|logout|status>");
+        process.exitCode = 1;
+        break;
+      default:
+        console.error(`Unknown auth action: ${action}. Available: login, logout, status`);
+        process.exitCode = 1;
+    }
   });
   cli.command("watch", "Watch GitHub issues and auto-respond with AI analysis").option("--interval <ms>", "Poll interval in milliseconds (default: 30000)").option("--dry-run", "Detect issues without posting responses").option("--force", "Kill existing watch process and start fresh").option("--verbose", "Enable verbose logging").action(async (options2) => {
     await watchCommand(options2);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sunasteriskrnd/takumi",
-	"version": "1.0.0-dev.1",
+	"version": "1.0.0-dev.2",
 	"description": "CLI tool for bootstrapping and managing Takumi projects",
 	"type": "module",
 	"repository": {