@astrale-os/cli 1.0.0-beta.9 → 1.0.0-npm-deprecated.0

package/src/telemetry/session.ts

@@ -1,88 +0,0 @@
-/**
- * Session identity: buckets CLI invocations by workspace (git root, else cwd).
- * ASTRALE_SESSION pins an explicit id owned by a surface; otherwise an ambient
- * session is reused within the idle window or minted per root. Never spawns a
- * child process; every fs touch is swallowed so telemetry can't break the CLI.
- */
-import { createHash } from 'node:crypto'
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
-import { dirname, join } from 'node:path'
-
-import type { SessionMeta } from './types'
-
-import { listSessions, metaPath, sessionDir } from './store'
-
-export type ResolvedSession = { id: string; root: string; explicit: boolean }
-
-const MAX_ID_LEN = 64
-
-/** Nearest ancestor of `start` (inclusive) containing a `.git` entry, else null. */
-function findGitRoot(start: string): string | null {
-  let dir = start
-  for (;;) {
-    if (existsSync(join(dir, '.git'))) return dir
-    const parent = dirname(dir)
-    if (parent === dir) return null
-    dir = parent
-  }
-}
-
-/** Keep only id-safe chars, capped to 64. */
-function sanitizeId(raw: string): string {
-  return raw.replace(/[^a-zA-Z0-9._-]/g, '').slice(0, MAX_ID_LEN)
-}
-
-/** Local-time yyyymmddHHmm stamp for a minted ambient id. */
-function stamp(d = new Date()): string {
-  const p = (n: number, w = 2) => String(n).padStart(w, '0')
-  return `${p(d.getFullYear(), 4)}${p(d.getMonth() + 1)}${p(d.getDate())}${p(d.getHours())}${p(d.getMinutes())}`
-}
-
-/** id of an open, ambient session already bucketed to `root`, else null.
- *  Analyzed sessions are never reused — a straggler event may "reopen" one
- *  after its report, and new work funneled there would never be analyzed. */
-function findOpenAmbient(root: string): string | null {
-  for (const s of listSessions()) {
-    if (s.meta?.root === root && s.meta.explicit === false && !s.closed && s.analyzed === null) {
-      return s.id
-    }
-  }
-  return null
-}
-
-function mintAmbientId(root: string): string {
-  const hash8 = createHash('sha256').update(root).digest('hex').slice(0, 8)
-  return `amb-${hash8}-${stamp()}`
-}
-
-/** Resolve the session identity for `cwd` without creating anything on disk. */
-export function resolveSession(cwd: string): ResolvedSession {
-  const root = findGitRoot(cwd) ?? cwd
-  const pinned = process.env.ASTRALE_SESSION
-  if (pinned) {
-    const id = sanitizeId(pinned)
-    if (id.length > 0) return { id, root, explicit: true }
-  }
-  return { id: findOpenAmbient(root) ?? mintAmbientId(root), root, explicit: false }
-}
-
-/** Resolve, then create the session dir + meta.json on first sight. */
-export function ensureSession(cwd: string): ResolvedSession {
-  const resolved = resolveSession(cwd)
-  const dir = sessionDir(resolved.id)
-  if (!existsSync(dir)) {
-    try {
-      mkdirSync(dir, { recursive: true })
-      const meta: SessionMeta = {
-        id: resolved.id,
-        root: resolved.root,
-        explicit: resolved.explicit,
-        createdAt: new Date().toISOString(),
-      }
-      writeFileSync(metaPath(resolved.id), JSON.stringify(meta, null, 2) + '\n')
-    } catch {
-      /* telemetry never breaks the CLI */
-    }
-  }
-  return resolved
-}

package/src/telemetry/settings.ts

@@ -1,26 +0,0 @@
-/**
- * Telemetry kill-switch, evaluated synchronously at process start/exit.
- * Off when ASTRALE_TELEMETRY is 0/false/off, or when config telemetry.enabled
- * is false; on by default. Every read silent-fails to enabled.
- */
-import { readFileSync } from 'node:fs'
-
-import { createPaths } from '../state/index'
-
-const OFF_VALUES = new Set(['0', 'false', 'off'])
-
-/** Whether telemetry recording is enabled for this process. */
-export function telemetryEnabled(): boolean {
-  const env = process.env.ASTRALE_TELEMETRY
-  if (env !== undefined && OFF_VALUES.has(env.trim().toLowerCase())) return false
-  try {
-    // Call-time path resolution — see sessionsRoot() in store.ts for why.
-    const parsed = JSON.parse(readFileSync(createPaths().config, 'utf-8')) as {
-      telemetry?: { enabled?: boolean }
-    }
-    if (parsed.telemetry?.enabled === false) return false
-  } catch {
-    /* missing or broken config → default on */
-  }
-  return true
-}

package/src/telemetry/store.ts

@@ -1,91 +0,0 @@
-/**
- * Session store layout under `~/.astrale/sessions/<id>/`:
- *   events.jsonl   append-only CLI events; its mtime IS the session's last-activity
- *   meta.json      SessionMeta, written once at creation
- *   .analyzed      AnalyzedMarker, written by the analyzer (any outcome)
- *   report.md      analyzer output
- * A session is CLOSED when events.jsonl's mtime is older than IDLE_WINDOW_MS.
- */
-import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs'
-import { join } from 'node:path'
-
-import type { AnalyzedMarker, SessionMeta } from './types'
-
-import { createPaths } from '../state/index'
-
-export const IDLE_WINDOW_MS = 30 * 60 * 1000
-
-// Resolved at CALL time (not import time) so ASTRALE_HOME set late — notably
-// by tests whose module-load order is out of their control — always applies.
-// The env can't change mid-process in real CLI runs, so behavior is identical.
-export function sessionsRoot(): string {
-  return join(createPaths().home, 'sessions')
-}
-
-export function sessionDir(id: string): string {
-  return join(sessionsRoot(), id)
-}
-
-export function eventsPath(id: string): string {
-  return join(sessionDir(id), 'events.jsonl')
-}
-
-export function metaPath(id: string): string {
-  return join(sessionDir(id), 'meta.json')
-}
-
-export function markerPath(id: string): string {
-  return join(sessionDir(id), '.analyzed')
-}
-
-export function reportPath(id: string): string {
-  return join(sessionDir(id), 'report.md')
-}
-
-export type SessionInfo = {
-  id: string
-  meta: SessionMeta | null
-  lastEventAt: Date | null
-  closed: boolean
-  analyzed: AnalyzedMarker | null
-}
-
-function readJsonSafe<T>(path: string): T | null {
-  try {
-    return JSON.parse(readFileSync(path, 'utf-8')) as T
-  } catch {
-    return null
-  }
-}
-
-export function inspectSession(id: string, now = Date.now()): SessionInfo | null {
-  const dir = sessionDir(id)
-  if (!existsSync(dir)) return null
-  let lastEventAt: Date | null = null
-  try {
-    lastEventAt = statSync(eventsPath(id)).mtime
-  } catch {
-    /* no events yet */
-  }
-  return {
-    id,
-    meta: readJsonSafe<SessionMeta>(metaPath(id)),
-    lastEventAt,
-    closed: lastEventAt !== null && now - lastEventAt.getTime() > IDLE_WINDOW_MS,
-    analyzed: readJsonSafe<AnalyzedMarker>(markerPath(id)),
-  }
-}
-
-/** All sessions, newest activity first. Missing store dir → empty list. */
-export function listSessions(now = Date.now()): SessionInfo[] {
-  let ids: string[]
-  try {
-    ids = readdirSync(sessionsRoot()).filter((n) => !n.startsWith('.'))
-  } catch {
-    return []
-  }
-  return ids
-    .map((id) => inspectSession(id, now))
-    .filter((s): s is SessionInfo => s !== null)
-    .sort((a, b) => (b.lastEventAt?.getTime() ?? 0) - (a.lastEventAt?.getTime() ?? 0))
-}

package/src/telemetry/trigger.ts

@@ -1,119 +0,0 @@
-/**
- * Opportunistic analysis trigger — the `git gc --auto` model. Each CLI start
- * cheaply scans for a closed, unanalyzed session and spawns ONE detached
- * analyzer for it. No daemon, no cron; a lockfile keeps it single-flight.
- */
-import { spawn } from 'node:child_process'
-import { existsSync, mkdirSync, readFileSync, rmSync, unlinkSync, writeFileSync } from 'node:fs'
-import { join } from 'node:path'
-
-import { telemetryEnabled } from './settings'
-import { listSessions, sessionDir, sessionsRoot, type SessionInfo } from './store'
-
-const LOCK_STALE_MS = 30 * 60 * 1000
-const GC_AGE_MS = 30 * 24 * 60 * 60 * 1000
-const GC_MAX_PER_RUN = 20
-
-/** Opportunistic GC: analyzed sessions idle past the retention age are removed
- *  (capped per invocation) so the store — and the per-invocation scan — stays
- *  bounded. Evidence worth keeping has left via reports or filed issues. */
-function gcOldSessions(sessions: SessionInfo[]): void {
-  try {
-    const cutoff = Date.now() - GC_AGE_MS
-    let removed = 0
-    for (const s of sessions) {
-      if (removed >= GC_MAX_PER_RUN) break
-      if (s.analyzed !== null && s.lastEventAt !== null && s.lastEventAt.getTime() < cutoff) {
-        rmSync(sessionDir(s.id), { recursive: true, force: true })
-        removed++
-      }
-    }
-  } catch {
-    /* best effort */
-  }
-}
-
-function lockPath(): string {
-  return join(sessionsRoot(), '.analyzer.lock')
-}
-
-/** True when the lock is free (or stale/dead) and was claimed. */
-function claimLock(): boolean {
-  const path = lockPath()
-  try {
-    if (existsSync(path)) {
-      const lock = JSON.parse(readFileSync(path, 'utf-8')) as { pid: number; at: number }
-      const stale = Date.now() - lock.at > LOCK_STALE_MS
-      let alive = false
-      try {
-        process.kill(lock.pid, 0)
-        alive = true
-      } catch {
-        /* dead */
-      }
-      if (alive && !stale) return false
-      unlinkSync(path)
-    }
-    mkdirSync(sessionsRoot(), { recursive: true })
-    writeFileSync(path, JSON.stringify({ pid: process.pid, at: Date.now() }))
-    return true
-  } catch {
-    return false
-  }
-}
-
-/** Release only in the parent that claimed; the child rewrites its own. */
-export function releaseLock(): void {
-  try {
-    unlinkSync(lockPath())
-  } catch {
-    /* already gone */
-  }
-}
-
-/**
- * Fire-and-forget: spawn a detached `astrale session analyze <id> --auto` for
- * the most recently closed unanalyzed session, if any. Never throws, never
- * blocks — worst case a few ms of directory stats.
- */
-export function maybeTriggerAnalysis(argv: string[]): void {
-  try {
-    if (!telemetryEnabled()) return
-    if (process.env.ASTRALE_TELEMETRY_NO_TRIGGER === '1') return
-    // Never cascade off the session commands themselves.
-    if (argv[2] === 'session') return
-
-    const sessions = listSessions()
-    gcOldSessions(sessions)
-    const target = sessions.find((s) => s.closed && s.analyzed === null && s.lastEventAt !== null)
-    if (!target) return
-    if (!claimLock()) return
-
-    // Re-invoke self: execPath is bun/node (dev) or the compiled binary; when
-    // argv[1] is a real script path, keep it as the first argument. In a
-    // bun-compiled binary argv[1] is a virtual /$bunfs/ path that must NOT be
-    // passed — the binary re-runs itself from execPath alone.
-    const script = process.argv[1]
-    const args =
-      script && script !== process.execPath && !script.startsWith('/$bunfs') ? [script] : []
-    args.push('session', 'analyze', target.id, '--auto')
-    const child = spawn(process.execPath, args, {
-      detached: true,
-      stdio: 'ignore',
-      env: { ...process.env, ASTRALE_TELEMETRY_NO_TRIGGER: '1' },
-    })
-    child.unref()
-    // The lock hands over to the child: it re-stamps with its own pid on start.
-  } catch {
-    /* telemetry must never affect the CLI */
-  }
-}
-
-/** Called by `session analyze --auto` to take over the parent's claim. */
-export function restampLock(): void {
-  try {
-    writeFileSync(lockPath(), JSON.stringify({ pid: process.pid, at: Date.now() }))
-  } catch {
-    /* best effort */
-  }
-}

package/src/telemetry/types.ts

@@ -1,64 +0,0 @@
-/**
- * Telemetry contracts. One CLI invocation = one appended event; one session =
- * one directory of evidence under `~/.astrale/sessions/`; harness adapters
- * contribute transcript discovery + a reading guide, never normalization.
- */
-
-/** One CLI invocation, one JSON line in events.jsonl. */
-export type TelemetryEvent = {
-  /** Envelope version. */
-  v: 1
-  /** ISO timestamp at process start. */
-  ts: string
-  /** argv after the binary name, secrets redacted (see redact.ts). */
-  argv: string[]
-  exitCode: number
-  durationMs: number
-  /** Error class name when the command threw (AstraleError code preferred). */
-  errorName?: string
-  cwd: string
-  /** Workspace root the session is bucketed by (git root, else cwd). */
-  root: string
-  /** Which surface produced the event. */
-  surface: 'cli'
-}
-
-/** Written once when a session directory is created. */
-export type SessionMeta = {
-  id: string
-  root: string
-  /** true when the id came from ASTRALE_SESSION (a surface owns the lifecycle). */
-  explicit: boolean
-  createdAt: string
-}
-
-/** Written by the analyzer when it finishes with a session (any outcome). */
-export type AnalyzedMarker = {
-  analyzedAt: string
-  outcome: 'skipped-quiet' | 'reported' | 'filed' | 'error'
-  note?: string
-}
-
-/** An agent-harness session discovered on this machine (transcript = evidence). */
-export type HarnessSession = {
-  harness: string
-  sessionId?: string
-  transcriptPath: string
-  cwd?: string
-  startedAt?: string
-  endedAt?: string
-  sizeBytes: number
-}
-
-/** Deterministic signals extracted from events.jsonl — the free gate's input. */
-export type SessionSignals = {
-  eventCount: number
-  /** Events with a non-zero exit, grouped by leading command tokens. */
-  failures: { command: string; count: number; errorNames: string[] }[]
-  /** Same leading command tokens re-run 3+ times (retry smell). */
-  retries: { command: string; count: number }[]
-  firstEventAt?: string
-  lastEventAt?: string
-  /** Harness transcripts overlapping this session's root + time window. */
-  harnessSessions: HarnessSession[]
-}

package/src/test-utils.ts

@@ -1,18 +0,0 @@
-import { mkdtemp, mkdir } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-
-import { createPaths, type Paths } from './state/index'
-
-export type TestEnv = {
-  paths: Paths
-  tmp: string
-}
-
-export async function createTestEnv(): Promise<TestEnv> {
-  const tmp = await mkdtemp(join(tmpdir(), 'astrale-test-'))
-  const paths = createPaths(tmp)
-  await mkdir(paths.keys, { recursive: true })
-  await mkdir(paths.data, { recursive: true })
-  return { paths, tmp }
-}

package/studio/client/dist/assets/elk-api-ByzoDZWH.js

@@ -1 +0,0 @@
-import{m as L}from"./index-N8J8EKlB.js";function S(y,b){for(var u=0;u<b.length;u++){const a=b[u];if(typeof a!="string"&&!Array.isArray(a)){for(const i in a)if(i!=="default"&&!(i in y)){const n=Object.getOwnPropertyDescriptor(a,i);n&&Object.defineProperty(y,i,n.get?n:{enumerable:!0,get:()=>a[i]})}}}return Object.freeze(Object.defineProperty(y,Symbol.toStringTag,{value:"Module"}))}function w(y){throw new Error('Could not dynamically require "'+y+'". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.')}var O={exports:{}},j;function C(){return j||(j=1,(function(y,b){(function(u){y.exports=u()})(function(){return(function(){function u(a,i,n){function d(f,_){if(!i[f]){if(!a[f]){var h=typeof w=="function"&&w;if(!_&&h)return h(f,!0);if(g)return g(f,!0);var o=new Error("Cannot find module '"+f+"'");throw o.code="MODULE_NOT_FOUND",o}var e=i[f]={exports:{}};a[f][0].call(e.exports,function(r){var t=a[f][1][r];return d(t||r)},e,e.exports,u,a,i,n)}return i[f].exports}for(var g=typeof w=="function"&&w,m=0;m<n.length;m++)d(n[m]);return d}return u})()({1:[function(u,a,i){Object.defineProperty(i,"__esModule",{value:!0}),i.default=void 0;function n(o){"@babel/helpers - typeof";return n=typeof Symbol=="function"&&typeof Symbol.iterator=="symbol"?function(e){return typeof e}:function(e){return e&&typeof Symbol=="function"&&e.constructor===Symbol&&e!==Symbol.prototype?"symbol":typeof e},n(o)}function d(o,e){if(!(o instanceof e))throw new TypeError("Cannot call a class as a function")}function g(o,e){for(var r=0;r<e.length;r++){var t=e[r];t.enumerable=t.enumerable||!1,t.configurable=!0,"value"in t&&(t.writable=!0),Object.defineProperty(o,f(t.key),t)}}function m(o,e,r){return e&&g(o.prototype,e),Object.defineProperty(o,"prototype",{writable:!1}),o}function f(o){var e=_(o,"string");return n(e)=="symbol"?e:e+""}function _(o,e){if(n(o)!="object"||!o)return o;var r=o[Symbol.toPrimitive];if(r!==void 0){var t=r.call(o,e);if(n(t)!="object")return t;throw new TypeError("@@toPrimitive must return a primitive value.")}return String(o)}i.default=(function(){function o(){var e=this,r=arguments.length>0&&arguments[0]!==void 0?arguments[0]:{},t=r.defaultLayoutOptions,s=t===void 0?{}:t,l=r.algorithms,v=l===void 0?["layered","stress","mrtree","radial","force","disco","sporeOverlap","sporeCompaction","rectpacking"]:l,c=r.workerFactory,p=r.workerUrl;if(d(this,o),this.defaultLayoutOptions=s,this.initialized=!1,typeof p>"u"&&typeof c>"u")throw new Error("Cannot construct an ELK without both 'workerUrl' and 'workerFactory'.");var k=c;typeof p<"u"&&typeof c>"u"&&(k=function(M){return new Worker(M)});var E=k(p);if(typeof E.postMessage!="function")throw new TypeError("Created worker does not provide the required 'postMessage' function.");this.worker=new h(E),this.worker.postMessage({cmd:"register",algorithms:v}).then(function(P){return e.initialized=!0}).catch(console.err)}return m(o,[{key:"layout",value:function(r){var t=arguments.length>1&&arguments[1]!==void 0?arguments[1]:{},s=t.layoutOptions,l=s===void 0?this.defaultLayoutOptions:s,v=t.logging,c=v===void 0?!1:v,p=t.measureExecutionTime,k=p===void 0?!1:p;return r?this.worker.postMessage({cmd:"layout",graph:r,layoutOptions:l,options:{logging:c,measureExecutionTime:k}}):Promise.reject(new Error("Missing mandatory parameter 'graph'."))}},{key:"knownLayoutAlgorithms",value:function(){return this.worker.postMessage({cmd:"algorithms"})}},{key:"knownLayoutOptions",value:function(){return this.worker.postMessage({cmd:"options"})}},{key:"knownLayoutCategories",value:function(){return this.worker.postMessage({cmd:"categories"})}},{key:"terminateWorker",value:function(){this.worker&&this.worker.terminate()}}])})();var h=(function(){function o(e){var r=this;if(d(this,o),e===void 0)throw new Error("Missing mandatory parameter 'worker'.");this.resolvers={},this.worker=e,this.worker.onmessage=function(t){setTimeout(function(){r.receive(r,t)},0)}}return m(o,[{key:"postMessage",value:function(r){var t=this.id||0;this.id=t+1,r.id=t;var s=this;return new Promise(function(l,v){s.resolvers[t]=function(c,p){c?(s.convertGwtStyleError(c),v(c)):l(p)},s.worker.postMessage(r)})}},{key:"receive",value:function(r,t){var s=t.data,l=r.resolvers[s.id];l&&(delete r.resolvers[s.id],s.error?l(s.error):l(null,s.data))}},{key:"terminate",value:function(){this.worker&&this.worker.terminate()}},{key:"convertGwtStyleError",value:function(r){if(r){var t=r.__java$exception;t&&(t.cause&&t.cause.backingJsObject&&(r.cause=t.cause.backingJsObject,this.convertGwtStyleError(r.cause)),delete r.__java$exception)}}}])})()},{}],2:[function(u,a,i){var n=u("./elk-api.js").default;Object.defineProperty(a.exports,"__esModule",{value:!0}),a.exports=n,n.default=n},{"./elk-api.js":1}]},{},[2])(2)})})(O)),O.exports}var x=C();const A=L(x),q=S({__proto__:null,default:A},[x]);export{q as e};