@fastagent-sh/voicenote 0.20.0 → 0.22.0

package/src/jobs.ts

@@ -20,10 +20,10 @@
 // fields have to agree about the same fact — an earlier cut expressed "gave up"
 // as `code` while leaving `state` alone, and the view and the classifier
 // promptly disagreed about what such a record was.
-export type JobState = 'queued' | 'running' | 'done' | 'filtered' | 'error' | 'gave_up'
+type JobState = 'queued' | 'running' | 'done' | 'filtered' | 'error' | 'gave_up'
 
 /** Which stage produced a failure; also carries the filter reason. */
-export type JobCode = 'transcribe_failed' | 'summary_failed' | 'interrupted' | 'too_small' | 'too_short' | 'too_old' | null
+type JobCode = 'transcribe_failed' | 'summary_failed' | 'interrupted' | 'too_small' | 'too_short' | 'too_old' | null
 
 export type JobRecord = {
   name: string
@@ -60,18 +60,18 @@ export const ownsOutput = (j: JobRecord): boolean => j.paths != null
 export const MAX_ATTEMPTS = 3
 
 /** The subset of JobCode a refusal may write to disk. */
-export type FilterCode = Extract<JobCode, 'too_small' | 'too_short' | 'too_old'>
+type FilterCode = Extract<JobCode, 'too_small' | 'too_short' | 'too_old'>
 
 // Split by whether the refusal is persisted, so the code that reaches disk is
 // typed as such. A single `code: string` needed a cast at the write site, and
 // the cast was the only thing keeping a display-only reason out of the record.
-export type Verdict =
+type Verdict =
   | { run: true }
   | { run: false; persist: true; code: FilterCode; detail: string | null }
   | { run: false; persist: false; code: 'already_done' | 'gave_up'; detail: string | null }
 
-export type ScanFacts = { recordedAt: Date; sizeBytes: number; durationSeconds: number | null }
-export type Limits = { maxAgeHours: number; minBytes: number; minDurationSeconds: number }
+type ScanFacts = { recordedAt: Date; sizeBytes: number; durationSeconds: number | null }
+type Limits = { maxAgeHours: number; minBytes: number; minDurationSeconds: number }
 
 /**
  * The single answer to "should this recording run now, and in what form".
@@ -114,7 +114,7 @@ export function classify(
 const RUNNABLE_STATES = new Set<JobState>(['queued', 'running', 'error'])
 
 /** Every way a started attempt can end. */
-export type Outcome =
+type Outcome =
   | { kind: 'done'; title: string | null; paths: Record<string, string | null> | null }
   | { kind: 'summary_failed'; title: string | null; paths: Record<string, string | null> | null; message: string }
   | { kind: 'failed'; message: string }
@@ -240,7 +240,7 @@ export function pruneUnseen(jobs: Record<string, JobRecord>, seen: Set<string>,
 
 export type CurrentJob = { pid: number; source_id: string; step: string; started_at: string }
 
-export type JobView = {
+type JobView = {
   status: 'running' | 'queued' | 'done' | 'notes_failed' | 'error' | 'gave_up' | 'filtered'
   name: string
   title: string | null
@@ -275,7 +275,7 @@ export function patchJob(entry: JobRecord, patch: Partial<JobRecord>, now: strin
 export const emptyState = (): StateFile => ({ version: 2, jobs: {} })
 
 /**
- * One meaning of `limit` for both front doors (the CLI flag and the GUI's RPC):
+ * One meaning of `limit` for both front doors (the CLI flag and the GUI's call):
  * 0 = no limit, absent = `fallback`, anything else must be a non-negative
  * integer. Coercing garbage to a default is how a truncated list gets mistaken
  * for a complete one — the exact bug this module exists to remove.
@@ -342,7 +342,7 @@ const FILTER_LABELS: Record<string, string> = {
 }
 
 /** `2026-07-29T12:06:29` → `2026-07-29 12:06`. */
-export function displayTime(recordedAt: string | null): string | null {
+function displayTime(recordedAt: string | null): string | null {
   if (!recordedAt) return null
   return recordedAt.slice(0, 16).replace('T', ' ')
 }

package/src/runLock.ts

@@ -4,7 +4,7 @@
 // to 'reclaimed'. The heartbeat and release paths branch on these three
 // states, and collapsing 'unknown' into 'reclaimed' (or 'mine') is exactly
 // the bug that would either hand a live lock away or delete a reclaimer's lock.
-export type LockOwnership = "mine" | "reclaimed" | "unknown";
+type LockOwnership = "mine" | "reclaimed" | "unknown";
 
 /**
  * @param raw    lock-file contents, or null if the file could not be read

package/src/tos.ts

@@ -0,0 +1,18 @@
+export type TosConfig = {
+  endpoint: string
+  region: string
+  bucket: string
+  accessKey: string
+  secretKey: string
+  keep: boolean
+}
+
+export function tosObject(config: TosConfig, key: string): Bun.S3File {
+  return new Bun.S3Client({
+    accessKeyId: config.accessKey,
+    secretAccessKey: config.secretKey,
+    region: config.region,
+    endpoint: `https://${config.bucket}.${config.endpoint}`,
+    virtualHostedStyle: true,
+  }).file(key)
+}

package/src/envConfig.ts

@@ -1,129 +0,0 @@
-// Pure logic behind cli.ts's env-config provenance. Extracted (no fs, no
-// process.env) so its invariants are testable — see envConfig.test.ts:
-//
-// 1. File precedence: config.json (GUI) wins over ~/.zshrc (legacy CLI).
-//    Simple $VAR/${VAR} references resolve from these values without running
-//    shell code; runtime hydration may also use inherited environment values.
-// 2. Hydration: only keys the real environment does NOT set are filled from
-//    files — an explicit empty string in the environment (e.g.
-//    VOICENOTE_PI_SUMMARY_TOOLS="") counts as set and is never overridden.
-// 3. Scheduler embedding: a value is embedded only when it is NOT recoverable
-//    from the files at run time — i.e. it is a real-environment value that the
-//    files either don't provide or provide differently. Hydrated values and
-//    real-env values equal to the file value are skipped (vn run re-reads the
-//    files each start, and scheduler env outranks config.json, so embedding a
-//    recoverable value would freeze it against future config edits).
-// 4. A real-env value that DIFFERS from the file value is embedded as a
-//    deliberate override, but reported (frozenOverrides) so the caller can
-//    warn: it may equally be a stale shell session shadowing a fresh config
-//    edit, and it will keep overriding until the scheduler is reinstalled.
-
-/** Omit `environment` when checking which values files can reproduce on their own. */
-export function parseFileEnv(
-  keys: readonly string[],
-  configData: Record<string, unknown>,
-  zshrcContent: string | null,
-  home: string,
-  environment: Record<string, string | undefined> = {},
-): Record<string, string> {
-  const raw = new Map<string, string>()
-  const literal = new Set<string>()
-  for (const key of keys) {
-    const v = configData[key]
-    if (typeof v === 'string') { raw.set(key, v); continue }
-    const pattern = new RegExp(`(?:^|\\n)\\s*export\\s+${key}=(?:"([^"]*)"|'([^']*)'|([^\\s"'#]+))`)
-    const match = zshrcContent?.match(pattern)
-    const value = match?.slice(1).find(v => v !== undefined)
-    if (value !== undefined) raw.set(key, value)
-    if (match?.[2] !== undefined) literal.add(key)
-  }
-  const resolved = new Map<string, string>()
-  const visiting = new Set<string>()
-  const resolve = (key: string): string => {
-    const cached = resolved.get(key)
-    if (cached !== undefined) return cached
-    if (visiting.has(key)) throw new Error(`Circular config variable reference: ${key}`)
-    visiting.add(key)
-    const value = raw.get(key)!
-    const expanded = literal.has(key) ? value : value.replace(/\\(\$)|\$(?:\{([A-Za-z_][A-Za-z0-9_]*)\}|([A-Za-z_][A-Za-z0-9_]*))/g, (token, escaped, braced, bare) => {
-      if (escaped) return escaped
-      const ref = braced || bare
-      if (ref === 'HOME') return home
-      // Unknown references stay literal, so they cannot look recoverable from files.
-      if (Object.hasOwn(environment, ref) && environment[ref] !== undefined) return environment[ref]!
-      return raw.has(ref) ? resolve(ref) : token
-    })
-    visiting.delete(key)
-    resolved.set(key, expanded)
-    return expanded
-  }
-  return Object.fromEntries(Array.from(raw.keys(), key => [key, resolve(key)]))
-}
-
-/** Which keys to copy from fileEnv into an environment (invariant 2). */
-export function hydrateFromFileEnv(
-  keys: readonly string[],
-  processEnv: Record<string, string | undefined>,
-  fileEnv: Record<string, string>,
-): Record<string, string> {
-  const out: Record<string, string> = {}
-  for (const key of keys) {
-    if (processEnv[key] !== undefined) continue // real env wins, incl. ""
-    const v = fileEnv[key]
-    if (v !== undefined) out[key] = v
-  }
-  return out
-}
-
-/**
- * Per-key no_proxy/NO_PROXY derivation, made pure so its provenance invariant
- * is testable (it is the whole reason envKeysToEmbed exists). Given the
- * current env value, any previously-captured pre-merge original, whether the
- * key is already marked hydrated, and whether a proxy is active, returns:
- *   - runtime: the value to put in the environment (always volcano-merged)
- *   - capture: the pre-merge real-env original to remember (or undefined:
- *       either we synthesized the value, or it was already captured) — this is
- *       what the scheduler embeds, never the merged value
- *   - hydrate: true when we synthesized the value from nothing (fully
- *       rebuildable at run time, so it must NOT be embedded)
- * Merge is idempotent, so re-running on an already-merged value (reload) is
- * safe; capture-once is preserved by honoring capturedOriginal.
- */
-export function deriveNoProxy(
-  current: string | undefined,
-  capturedOriginal: string | undefined,
-  alreadyHydrated: boolean,
-  proxyActive: boolean,
-  base: string,
-  volcanoHosts: readonly string[],
-): { runtime: string; capture: string | undefined; hydrate: boolean } {
-  const merge = (v: string): string => {
-    const items = v.split(',').map(s => s.trim()).filter(Boolean)
-    for (const h of volcanoHosts) if (!items.includes(h)) items.push(h)
-    return items.join(',')
-  }
-  if (current === undefined) {
-    return { runtime: merge(proxyActive ? base : ''), capture: undefined, hydrate: true }
-  }
-  const capture = (!alreadyHydrated && capturedOriginal === undefined) ? current : undefined
-  return { runtime: merge(current), capture, hydrate: false }
-}
-
-/** Which env values the scheduler must snapshot (invariants 3 + 4). */
-export function envKeysToEmbed(
-  keys: readonly string[],
-  processEnv: Record<string, string | undefined>,
-  hydratedKeys: ReadonlySet<string>,
-  fileEnv: Record<string, string>,
-): { embed: Record<string, string>; frozenOverrides: string[] } {
-  const embed: Record<string, string> = {}
-  const frozenOverrides: string[] = []
-  for (const k of keys) {
-    const v = processEnv[k]
-    if (v === undefined) continue
-    if (hydratedKeys.has(k) || fileEnv[k] === v) continue // recoverable at run time
-    embed[k] = v
-    if (fileEnv[k] !== undefined) frozenOverrides.push(k)
-  }
-  return { embed, frozenOverrides }
-}