@cuongtran001/kanna 0.39.2

package/src/shared/analytics.ts

@@ -0,0 +1,30 @@
+export const ANALYTICS_ENDPOINT = "https://kanna.sh/api/t"
+
+export const ANALYTICS_STATIC_EVENT_NAMES = [
+  "app_launch",
+  "project_opened",
+  "project_created",
+  "project_removed",
+  "chat_created",
+  "chat_deleted",
+  "message_sent",
+  "update_checked",
+  "update_installed",
+  "update_failed",
+  "analytics_enabled",
+  "analytics_disabled",
+] as const
+
+export const ANALYTICS_STATIC_PROPERTY_NAMES = [
+  "current_version",
+  "environment",
+  "latest_version",
+  "custom_port_enabled",
+  "no_open_enabled",
+  "password_enabled",
+  "strict_port_enabled",
+  "remote_enabled",
+  "host_enabled",
+  "share_quick_enabled",
+  "share_token_enabled",
+] as const

package/src/shared/branding.test.ts

@@ -0,0 +1,31 @@
+import { describe, expect, test } from "bun:test"
+import {
+  getDataDir,
+  getDataDirDisplay,
+  getDataRootName,
+  getKeybindingsFilePath,
+  getKeybindingsFilePathDisplay,
+  getRuntimeProfile,
+} from "./branding"
+
+describe("runtime profile helpers", () => {
+  test("defaults to the prod profile when unset", () => {
+    expect(getRuntimeProfile({})).toBe("prod")
+    expect(getDataRootName({})).toBe(".kanna")
+    expect(getDataDir("/tmp/home", {})).toBe("/tmp/home/.kanna/data")
+    expect(getDataDirDisplay({})).toBe("~/.kanna/data")
+    expect(getKeybindingsFilePath("/tmp/home", {})).toBe("/tmp/home/.kanna/keybindings.json")
+    expect(getKeybindingsFilePathDisplay({})).toBe("~/.kanna/keybindings.json")
+  })
+
+  test("switches to dev paths for the dev profile", () => {
+    const env = { KANNA_RUNTIME_PROFILE: "dev" }
+
+    expect(getRuntimeProfile(env)).toBe("dev")
+    expect(getDataRootName(env)).toBe(".kanna-dev")
+    expect(getDataDir("/tmp/home", env)).toBe("/tmp/home/.kanna-dev/data")
+    expect(getDataDirDisplay(env)).toBe("~/.kanna-dev/data")
+    expect(getKeybindingsFilePath("/tmp/home", env)).toBe("/tmp/home/.kanna-dev/keybindings.json")
+    expect(getKeybindingsFilePathDisplay(env)).toBe("~/.kanna-dev/keybindings.json")
+  })
+})

package/src/shared/branding.ts

@@ -0,0 +1,77 @@
+export const APP_NAME = "Kanna"
+export const CLI_COMMAND = "kanna"
+export const DATA_ROOT_NAME = ".kanna"
+export const DEV_DATA_ROOT_NAME = ".kanna-dev"
+export const PACKAGE_NAME = "@cuongtran001/kanna"
+export const RUNTIME_PROFILE_ENV_VAR = "KANNA_RUNTIME_PROFILE"
+// Read version from package.json — JSON import works in both Bun and Vite
+import pkg from "../../package.json"
+export const APP_VERSION = pkg.version
+export const SDK_CLIENT_APP = `kanna/${pkg.version}`
+export const LOG_PREFIX = "[kanna]"
+export const DEFAULT_NEW_PROJECT_ROOT = `~/${APP_NAME}`
+
+export type RuntimeProfile = "dev" | "prod"
+
+type RuntimeEnv = Record<string, string | undefined> | undefined
+
+function getRuntimeEnv(): RuntimeEnv {
+  const candidate = globalThis as typeof globalThis & {
+    process?: {
+      env?: Record<string, string | undefined>
+    }
+  }
+  return candidate.process?.env
+}
+
+export function getRuntimeProfile(env: RuntimeEnv = getRuntimeEnv()): RuntimeProfile {
+  return env?.[RUNTIME_PROFILE_ENV_VAR]?.trim().toLowerCase() === "dev" ? "dev" : "prod"
+}
+
+export function getDataRootName(env: RuntimeEnv = getRuntimeEnv()) {
+  return getRuntimeProfile(env) === "dev" ? DEV_DATA_ROOT_NAME : DATA_ROOT_NAME
+}
+
+export function getDataRootDir(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+  return `${homeDir}/${getDataRootName(env)}`
+}
+
+export function getDataRootDirDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+  return `~/${getDataRootName(env)}`
+}
+
+export function getDataDir(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataRootDir(homeDir, env)}/data`
+}
+
+export function getDataDirDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataRootDirDisplay(env)}/data`
+}
+
+export function getSettingsFilePath(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataDir(homeDir, env)}/settings.json`
+}
+
+export function getSettingsFilePathDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataDirDisplay(env)}/settings.json`
+}
+
+export function getKeybindingsFilePath(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataRootDir(homeDir, env)}/keybindings.json`
+}
+
+export function getKeybindingsFilePathDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataRootDirDisplay(env)}/keybindings.json`
+}
+
+export function getLlmProviderFilePath(homeDir: string, env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataRootDir(homeDir, env)}/llm-provider.json`
+}
+
+export function getLlmProviderFilePathDisplay(env: RuntimeEnv = getRuntimeEnv()) {
+  return `${getDataRootDirDisplay(env)}/llm-provider.json`
+}
+
+export function getCliInvocation(arg?: string) {
+  return arg ? `${CLI_COMMAND} ${arg}` : CLI_COMMAND
+}

package/src/shared/dev-ports.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, test } from "bun:test"
+import {
+  DEFAULT_DEV_CLIENT_PORT,
+  getDefaultDevServerPort,
+  parseDevArgs,
+  resolveDevPorts,
+  stripShareArg,
+  stripPortArg,
+} from "./dev-ports"
+
+describe("getDefaultDevServerPort", () => {
+  test("derives the default backend port from the client port", () => {
+    expect(getDefaultDevServerPort()).toBe(DEFAULT_DEV_CLIENT_PORT + 1)
+    expect(getDefaultDevServerPort(4000)).toBe(4001)
+  })
+})
+
+describe("resolveDevPorts", () => {
+  test("uses default dev ports when no port override is provided", () => {
+    expect(resolveDevPorts([])).toEqual({
+      clientPort: DEFAULT_DEV_CLIENT_PORT,
+      serverPort: DEFAULT_DEV_CLIENT_PORT + 1,
+    })
+  })
+
+  test("treats --port as the client port and derives the backend port", () => {
+    expect(resolveDevPorts(["--remote", "--port", "4000"])).toEqual({
+      clientPort: 4000,
+      serverPort: 4001,
+    })
+  })
+
+  test("uses the last provided --port value", () => {
+    expect(resolveDevPorts(["--port", "4000", "--port", "4100"])).toEqual({
+      clientPort: 4100,
+      serverPort: 4101,
+    })
+  })
+
+  test("throws when --port is missing a value", () => {
+    expect(() => resolveDevPorts(["--port"])).toThrow("Missing value for --port")
+    expect(() => resolveDevPorts(["--port", "--remote"])).toThrow("Missing value for --port")
+  })
+})
+
+describe("stripPortArg", () => {
+  test("removes --port and its value while preserving other args", () => {
+    expect(stripPortArg(["--remote", "--port", "4000", "--host", "dev-box"])).toEqual([
+      "--remote",
+      "--host",
+      "dev-box",
+    ])
+  })
+})
+
+describe("stripShareArg", () => {
+  test("removes --share and --cloudflared arguments while preserving other args", () => {
+    expect(stripShareArg(["--remote", "--share", "--cloudflared", "secret-token", "--host", "dev-box"])).toEqual([
+      "--remote",
+      "--host",
+      "dev-box",
+    ])
+  })
+})
+
+describe("parseDevArgs", () => {
+  test("derives dev share options from the client port", () => {
+    expect(parseDevArgs(["--share", "--port", "3333"], "dev-machine")).toEqual({
+      clientPort: 3333,
+      serverPort: 3334,
+      share: "quick",
+      backendTargetHost: "127.0.0.1",
+      allowedHosts: true,
+      serverArgs: [],
+    })
+  })
+
+  test("accepts a token-bearing cloudflared dev mode", () => {
+    expect(parseDevArgs(["--cloudflared", "secret-token", "--port", "3333"], "dev-machine")).toEqual({
+      clientPort: 3333,
+      serverPort: 3334,
+      share: { kind: "token", token: "secret-token" },
+      backendTargetHost: "127.0.0.1",
+      allowedHosts: true,
+      serverArgs: [],
+    })
+  })
+
+  test("rejects combining --share with --host or --remote", () => {
+    expect(() => parseDevArgs(["--share", "--host", "dev-box"], "dev-machine")).toThrow("--share cannot be used with --host")
+    expect(() => parseDevArgs(["--host", "dev-box", "--share"], "dev-machine")).toThrow("--share cannot be used with --host")
+    expect(() => parseDevArgs(["--share", "--remote"], "dev-machine")).toThrow("--share cannot be used with --remote")
+    expect(() => parseDevArgs(["--remote", "--share"], "dev-machine")).toThrow("--share cannot be used with --remote")
+  })
+
+  test("rejects combining --cloudflared with --host or --remote", () => {
+    expect(() => parseDevArgs(["--cloudflared", "secret-token", "--host", "dev-box"], "dev-machine")).toThrow("--cloudflared cannot be used with --host")
+    expect(() => parseDevArgs(["--host", "dev-box", "--cloudflared", "secret-token"], "dev-machine")).toThrow("--cloudflared cannot be used with --host")
+    expect(() => parseDevArgs(["--cloudflared", "secret-token", "--remote"], "dev-machine")).toThrow("--cloudflared cannot be used with --remote")
+    expect(() => parseDevArgs(["--remote", "--cloudflared", "secret-token"], "dev-machine")).toThrow("--cloudflared cannot be used with --remote")
+  })
+
+  test("preserves existing remote host behavior when share is off", () => {
+    expect(parseDevArgs(["--remote", "--port", "3333"], "dev-machine")).toEqual({
+      clientPort: 3333,
+      serverPort: 3334,
+      share: false,
+      backendTargetHost: "127.0.0.1",
+      allowedHosts: true,
+      serverArgs: ["--remote"],
+    })
+  })
+})

package/src/shared/dev-ports.ts

@@ -0,0 +1,134 @@
+import type { ShareMode } from "./share"
+import { assertNoHostOverride, getShareCliFlag, isShareEnabled } from "./share"
+
+export const DEFAULT_DEV_CLIENT_PORT = 5174
+
+export function getDefaultDevServerPort(clientPort = DEFAULT_DEV_CLIENT_PORT) {
+  return clientPort + 1
+}
+
+export interface DevArgResolution {
+  clientPort: number
+  serverPort: number
+  share: ShareMode
+  backendTargetHost: string
+  allowedHosts: true | string[]
+  serverArgs: string[]
+}
+
+export function resolveDevPorts(args: string[]) {
+  let clientPort = DEFAULT_DEV_CLIENT_PORT
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index]
+    if (arg !== "--port") continue
+
+    const next = args[index + 1]
+    if (!next || next.startsWith("-")) {
+      throw new Error("Missing value for --port")
+    }
+
+    clientPort = Number(next)
+    index += 1
+  }
+
+  return {
+    clientPort,
+    serverPort: getDefaultDevServerPort(clientPort),
+  }
+}
+
+export function stripPortArg(args: string[]) {
+  const stripped: string[] = []
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index]
+    if (arg === "--port") {
+      index += 1
+      continue
+    }
+
+    stripped.push(arg)
+  }
+
+  return stripped
+}
+
+export function stripShareArg(args: string[]) {
+  const stripped: string[] = []
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index]
+    if (arg === "--share") {
+      continue
+    }
+
+    if (arg === "--cloudflared") {
+      index += 1
+      continue
+    }
+
+    if (arg !== "--share") {
+      stripped.push(arg)
+    }
+  }
+
+  return stripped
+}
+
+export function parseDevArgs(args: string[], localHostname: string): DevArgResolution {
+  const { clientPort, serverPort } = resolveDevPorts(args)
+  const serverArgs = stripShareArg(stripPortArg(args))
+  let share: ShareMode = false
+  let sawHost = false
+  let sawRemote = false
+  let backendTargetHost = "127.0.0.1"
+  let allowAllHosts = false
+  const hosts = new Set<string>(["localhost", "127.0.0.1", "0.0.0.0", localHostname])
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index]
+    if (arg === "--share") {
+      assertNoHostOverride("--share", sawHost, sawRemote)
+      share = "quick"
+      continue
+    }
+    if (arg === "--cloudflared") {
+      assertNoHostOverride("--cloudflared", sawHost, sawRemote)
+      const next = args[index + 1]
+      if (!next || next.startsWith("-")) throw new Error("Missing value for --cloudflared")
+      share = { kind: "token", token: next }
+      index += 1
+      continue
+    }
+    if (arg === "--remote") {
+      if (isShareEnabled(share)) {
+        throw new Error(`${getShareCliFlag(share)} cannot be used with --remote`)
+      }
+      sawRemote = true
+      backendTargetHost = "127.0.0.1"
+      allowAllHosts = true
+      continue
+    }
+    if (arg !== "--host") continue
+
+    const next = args[index + 1]
+    if (!next || next.startsWith("-")) continue
+    if (isShareEnabled(share)) {
+      throw new Error(`${getShareCliFlag(share)} cannot be used with --host`)
+    }
+    sawHost = true
+    hosts.add(next)
+    backendTargetHost = next === "0.0.0.0" ? "127.0.0.1" : next
+    index += 1
+  }
+
+  return {
+    clientPort,
+    serverPort,
+    share,
+    backendTargetHost,
+    allowedHosts: isShareEnabled(share) || allowAllHosts ? true : [...hosts],
+    serverArgs,
+  }
+}

package/src/shared/ports.ts

@@ -0,0 +1,2 @@
+export const PROD_SERVER_PORT = 3210
+export const DEV_CLIENT_PORT = 5174

package/src/shared/protocol.ts

@@ -0,0 +1,257 @@
+import type {
+  AppSettingsSnapshot,
+  AppSettingsPatch,
+  AgentProvider,
+  ChatAttachment,
+  ChatDiffSnapshot,
+  ChatHistoryPage,
+  ChatSnapshot,
+  CloudflareTunnelSettings,
+  DiffCommitMode,
+  KeybindingsSnapshot,
+  LlmProviderSnapshot,
+  LocalProjectsSnapshot,
+  ModelOptions,
+  SidebarData,
+  StandaloneTranscriptAttachmentMode,
+  StandaloneTranscriptExportResult,
+  UpdateSnapshot,
+  EditorPreset,
+} from "./types"
+
+export type { EditorPreset }
+
+export interface EditorOpenSettings {
+  preset: EditorPreset
+  commandTemplate: string
+}
+
+export type SubscriptionTopic =
+  | { type: "sidebar" }
+  | { type: "local-projects" }
+  | { type: "update" }
+  | { type: "keybindings" }
+  | { type: "app-settings" }
+  | { type: "chat"; chatId: string; recentLimit?: number }
+  | { type: "project-git"; projectId: string }
+  | { type: "terminal"; terminalId: string }
+
+export interface TerminalSnapshot {
+  terminalId: string
+  title: string
+  cwd: string
+  shell: string
+  cols: number
+  rows: number
+  scrollback: number
+  serializedState: string
+  status: "running" | "exited"
+  exitCode: number | null
+  signal?: number
+}
+
+export type TerminalEvent =
+  | { type: "terminal.output"; terminalId: string; data: string }
+  | { type: "terminal.exit"; terminalId: string; exitCode: number; signal?: number }
+
+export type ClientCommand =
+  | { type: "project.open"; localPath: string }
+  | { type: "project.create"; localPath: string; title: string }
+  | { type: "sessions.importClaude" }
+  | { type: "project.remove"; projectId: string }
+  | { type: "sidebar.reorderProjectGroups"; projectIds: string[] }
+  | { type: "project.readDiffPatch"; projectId: string; path: string }
+  | { type: "system.ping" }
+  | { type: "update.check"; force?: boolean }
+  | { type: "update.install" }
+  | { type: "update.reload" }
+  | { type: "settings.readKeybindings" }
+  | { type: "settings.writeKeybindings"; bindings: KeybindingsSnapshot["bindings"] }
+  | { type: "settings.readAppSettings" }
+  | { type: "settings.writeAppSettings"; analyticsEnabled: boolean }
+  | { type: "appSettings.setCloudflareTunnel"; patch: Partial<CloudflareTunnelSettings> }
+  | { type: "settings.writeAppSettingsPatch"; patch: AppSettingsPatch }
+  | { type: "settings.readLlmProvider" }
+  | {
+      type: "settings.writeLlmProvider"
+      provider: LlmProviderSnapshot["provider"]
+      apiKey: string
+      model: string
+      baseUrl: string
+    }
+  | {
+      type: "settings.validateLlmProvider"
+      provider: LlmProviderSnapshot["provider"]
+      apiKey: string
+      model: string
+      baseUrl: string
+    }
+  | {
+      type: "system.openExternal"
+      localPath: string
+      action: "open_finder" | "open_terminal" | "open_editor" | "open_preview" | "open_default"
+      line?: number
+      column?: number
+      editor?: EditorOpenSettings
+    }
+  | { type: "chat.create"; projectId: string }
+  | { type: "chat.fork"; chatId: string }
+  | { type: "chat.rename"; chatId: string; title: string }
+  | { type: "chat.archive"; chatId: string }
+  | { type: "chat.unarchive"; chatId: string }
+  | { type: "chat.delete"; chatId: string }
+  | { type: "chat.setDraftProtection"; chatIds: string[] }
+  | { type: "chat.markRead"; chatId: string }
+  | {
+      type: "chat.send"
+      chatId?: string
+      projectId?: string
+      clientTraceId?: string
+      provider?: AgentProvider
+      content: string
+      attachments?: ChatAttachment[]
+      model?: string
+      modelOptions?: ModelOptions
+      effort?: string
+      planMode?: boolean
+      autoResumeOnRateLimit?: boolean
+    }
+  | { type: "chat.refreshDiffs"; chatId: string }
+  | { type: "chat.initGit"; chatId: string }
+  | { type: "chat.getGitHubPublishInfo"; chatId: string }
+  | { type: "chat.checkGitHubRepoAvailability"; chatId: string; owner: string; name: string }
+  | {
+      type: "chat.publishToGitHub"
+      chatId: string
+      owner: string
+      name: string
+      visibility: "public" | "private"
+      description?: string
+    }
+  | { type: "chat.listBranches"; chatId: string }
+  | {
+      type: "chat.previewMergeBranch"
+      chatId: string
+      branch:
+      | { kind: "local"; name: string }
+      | { kind: "remote"; name: string; remoteRef: string }
+      | {
+          kind: "pull_request"
+          name: string
+          prNumber: number
+          headRefName: string
+          headRepoCloneUrl?: string
+          isCrossRepository?: boolean
+          remoteRef?: string
+        }
+    }
+  | {
+      type: "chat.mergeBranch"
+      chatId: string
+      branch:
+      | { kind: "local"; name: string }
+      | { kind: "remote"; name: string; remoteRef: string }
+      | {
+          kind: "pull_request"
+          name: string
+          prNumber: number
+          headRefName: string
+          headRepoCloneUrl?: string
+          isCrossRepository?: boolean
+          remoteRef?: string
+        }
+    }
+  | { type: "chat.syncBranch"; chatId: string; action: "fetch" | "pull" | "push" | "publish" }
+  | {
+      type: "chat.checkoutBranch"
+      chatId: string
+      branch:
+      | { kind: "local"; name: string }
+      | { kind: "remote"; name: string; remoteRef: string }
+      | {
+          kind: "pull_request"
+          name: string
+          prNumber: number
+          headRefName: string
+          headRepoCloneUrl?: string
+          isCrossRepository?: boolean
+          remoteRef?: string
+        }
+      bringChanges?: boolean
+    }
+  | { type: "chat.createBranch"; chatId: string; name: string; baseBranchName?: string }
+  | { type: "chat.generateCommitMessage"; chatId: string; paths: string[] }
+  | { type: "chat.commitDiffs"; chatId: string; paths: string[]; summary: string; description?: string; mode: DiffCommitMode }
+  | { type: "chat.discardDiffFile"; chatId: string; path: string }
+  | { type: "chat.ignoreDiffFile"; chatId: string; path: string }
+  | { type: "chat.cancel"; chatId: string }
+  | { type: "chat.stopDraining"; chatId: string }
+  | {
+      type: "chat.exportStandalone"
+      chatId: string
+      theme: "light" | "dark"
+      attachmentMode: StandaloneTranscriptAttachmentMode
+    }
+  | { type: "chat.loadHistory"; chatId: string; beforeCursor: string; limit: number }
+  | { type: "chat.respondTool"; chatId: string; toolUseId: string; result: unknown }
+  | {
+      type: "message.enqueue"
+      chatId: string
+      content: string
+      attachments?: ChatAttachment[]
+      provider?: AgentProvider
+      model?: string
+      modelOptions?: ModelOptions
+      planMode?: boolean
+      autoResumeOnRateLimit?: boolean
+    }
+  | {
+      type: "message.steer"
+      chatId: string
+      queuedMessageId: string
+    }
+  | {
+      type: "message.dequeue"
+      chatId: string
+      queuedMessageId: string
+    }
+  | { type: "autoContinue.accept"; chatId: string; scheduleId: string; scheduledAt: number }
+  | { type: "autoContinue.reschedule"; chatId: string; scheduleId: string; scheduledAt: number }
+  | { type: "autoContinue.cancel"; chatId: string; scheduleId: string }
+  | { type: "tunnel.accept"; chatId: string; tunnelId: string }
+  | { type: "tunnel.stop"; chatId: string; tunnelId: string }
+  | { type: "tunnel.retry"; chatId: string; tunnelId: string }
+  | { type: "terminal.create"; projectId: string; terminalId: string; cols: number; rows: number; scrollback: number }
+  | { type: "terminal.input"; terminalId: string; data: string }
+  | { type: "terminal.resize"; terminalId: string; cols: number; rows: number }
+  | { type: "terminal.close"; terminalId: string }
+
+export type OpenExternalAction = Extract<ClientCommand, { type: "system.openExternal" }>["action"]
+
+export type ClientEnvelope =
+  | { v: 1; type: "subscribe"; id: string; topic: SubscriptionTopic }
+  | { v: 1; type: "unsubscribe"; id: string }
+  | { v: 1; type: "command"; id: string; command: ClientCommand }
+
+export type ServerSnapshot =
+  | { type: "sidebar"; data: SidebarData }
+  | { type: "local-projects"; data: LocalProjectsSnapshot }
+  | { type: "update"; data: UpdateSnapshot }
+  | { type: "keybindings"; data: KeybindingsSnapshot }
+  | { type: "app-settings"; data: AppSettingsSnapshot }
+  | { type: "llm-provider"; data: LlmProviderSnapshot }
+  | { type: "chat"; data: ChatSnapshot | null }
+  | { type: "project-git"; data: ChatDiffSnapshot | null }
+  | { type: "terminal"; data: TerminalSnapshot | null }
+
+export type ServerEnvelope =
+  | { v: 1; type: "snapshot"; id: string; snapshot: ServerSnapshot }
+  | { v: 1; type: "event"; id: string; event: TerminalEvent }
+  | { v: 1; type: "ack"; id: string; result?: unknown | ChatHistoryPage | StandaloneTranscriptExportResult }
+  | { v: 1; type: "error"; id?: string; message: string }
+
+export function isClientEnvelope(value: unknown): value is ClientEnvelope {
+  if (!value || typeof value !== "object") return false
+  const candidate = value as Partial<ClientEnvelope>
+  return candidate.v === 1 && typeof candidate.type === "string"
+}

package/src/shared/share.ts

@@ -0,0 +1,27 @@
+export type ShareMode = false | "quick" | {
+  kind: "token"
+  token: string
+}
+
+export type ShareCliFlag = "--share" | "--cloudflared"
+
+export function isShareEnabled(share: ShareMode): share is Exclude<ShareMode, false> {
+  return share !== false
+}
+
+export function isTokenShareMode(share: ShareMode): share is { kind: "token"; token: string } {
+  return typeof share === "object" && share !== null && share.kind === "token"
+}
+
+export function getShareCliFlag(share: Exclude<ShareMode, false>): ShareCliFlag {
+  return isTokenShareMode(share) ? "--cloudflared" : "--share"
+}
+
+export function assertNoHostOverride(shareFlag: ShareCliFlag, sawHost: boolean, sawRemote: boolean) {
+  if (sawHost) {
+    throw new Error(`${shareFlag} cannot be used with --host`)
+  }
+  if (sawRemote) {
+    throw new Error(`${shareFlag} cannot be used with --remote`)
+  }
+}