boxdown 1.0.0 → 1.2.0

package/src/metadata.ts

@@ -13,6 +13,14 @@ export interface WorkspaceMetadata {
   sshAlias: string
   firstSeenAt: string
   lastSeenAt: string
+  dockerImageId?: string
+  dockerImageName?: string
+  dockerImageLastSeenAt?: string
+}
+
+export interface WorkspaceDockerImageMetadata {
+  id: string
+  name?: string
 }
 
 function isWorkspaceMetadata (value: unknown): value is WorkspaceMetadata {
@@ -28,7 +36,10 @@ function isWorkspaceMetadata (value: unknown): value is WorkspaceMetadata {
     typeof candidate.workspaceBasename === 'string' &&
     typeof candidate.sshAlias === 'string' &&
     typeof candidate.firstSeenAt === 'string' &&
-    typeof candidate.lastSeenAt === 'string'
+    typeof candidate.lastSeenAt === 'string' &&
+    (candidate.dockerImageId === undefined || typeof candidate.dockerImageId === 'string') &&
+    (candidate.dockerImageName === undefined || typeof candidate.dockerImageName === 'string') &&
+    (candidate.dockerImageLastSeenAt === undefined || typeof candidate.dockerImageLastSeenAt === 'string')
 }
 
 export function workspaceMetadataPath (context: WorkspaceContext): string {
@@ -45,13 +56,25 @@ export function readWorkspaceMetadataFile (path: string): WorkspaceMetadata {
   return parsed
 }
 
+export function readWorkspaceMetadata (context: WorkspaceContext): WorkspaceMetadata | undefined {
+  const metadataPath = workspaceMetadataPath(context)
+
+  if (!existsSync(metadataPath)) {
+    return undefined
+  }
+
+  return readWorkspaceMetadataFile(metadataPath)
+}
+
 export function writeWorkspaceMetadata (context: WorkspaceContext, sshAlias: string, now = new Date()): WorkspaceMetadata {
   const metadataPath = workspaceMetadataPath(context)
   const timestamp = now.toISOString()
   let firstSeenAt = timestamp
+  let existingMetadata: WorkspaceMetadata | undefined
 
   if (existsSync(metadataPath)) {
-    firstSeenAt = readWorkspaceMetadataFile(metadataPath).firstSeenAt
+    existingMetadata = readWorkspaceMetadataFile(metadataPath)
+    firstSeenAt = existingMetadata.firstSeenAt
   }
 
   const metadata: WorkspaceMetadata = {
@@ -61,7 +84,10 @@ export function writeWorkspaceMetadata (context: WorkspaceContext, sshAlias: str
     workspaceBasename: context.workspaceBasename,
     sshAlias,
     firstSeenAt,
-    lastSeenAt: timestamp
+    lastSeenAt: timestamp,
+    ...(existingMetadata?.dockerImageId === undefined ? {} : { dockerImageId: existingMetadata.dockerImageId }),
+    ...(existingMetadata?.dockerImageName === undefined ? {} : { dockerImageName: existingMetadata.dockerImageName }),
+    ...(existingMetadata?.dockerImageLastSeenAt === undefined ? {} : { dockerImageLastSeenAt: existingMetadata.dockerImageLastSeenAt })
   }
 
   mkdirSync(context.workspaceDataDir, { recursive: true })
@@ -69,6 +95,29 @@ export function writeWorkspaceMetadata (context: WorkspaceContext, sshAlias: str
   return metadata
 }
 
+export function recordWorkspaceDockerImage (
+  context: WorkspaceContext,
+  image: WorkspaceDockerImageMetadata,
+  now = new Date()
+): WorkspaceMetadata | undefined {
+  const metadata = readWorkspaceMetadata(context)
+
+  if (metadata === undefined) {
+    return undefined
+  }
+
+  const nextMetadata: WorkspaceMetadata = {
+    ...metadata,
+    dockerImageId: image.id,
+    ...(image.name === undefined ? {} : { dockerImageName: image.name }),
+    dockerImageLastSeenAt: now.toISOString()
+  }
+
+  mkdirSync(context.workspaceDataDir, { recursive: true })
+  writeFileSync(workspaceMetadataPath(context), `${JSON.stringify(nextMetadata, null, 2)}\n`)
+  return nextMetadata
+}
+
 export function listWorkspaceMetadata (dataRoot: string): WorkspaceMetadata[] {
   const workspacesDir = join(dataRoot, 'workspaces')
 

package/src/package-info.ts

@@ -0,0 +1,18 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { packageRootFromImportMeta } from './paths.ts'
+
+interface PackageJson {
+  version?: unknown
+}
+
+export function readPackageVersion (packageRoot = packageRootFromImportMeta(import.meta.url)): string {
+  const packageJson = JSON.parse(readFileSync(join(packageRoot, 'package.json'), 'utf8')) as PackageJson
+
+  if (typeof packageJson.version !== 'string' || packageJson.version.length === 0) {
+    throw new Error('Boxdown package.json is missing a valid version.')
+  }
+
+  return packageJson.version
+}

package/src/paths.ts

@@ -26,11 +26,24 @@ export interface WorkspaceContext {
   workspaceDataDir: string
   generatedConfigPath: string
   hostAgentsDir: string
+  hostCodexAuthPath: string
+  hostGitconfigPath: string
+  hostGitconfigSnapshotDir: string
+  hostGitconfigSnapshotPath: string
+  gitSigningStateDir: string
+  gitSigningPublicKeyPath: string
   sshKeyDir: string
   sshKeyPath: string
   sshPublicKeyPath: string
   sshPublicKeyRuntimeDir: string
   sshPublicKeyRuntimePath: string
+  workspaceLogPath: string
+}
+
+export interface WorkspaceContextIdentity {
+  workspaceFolder: string
+  workspaceBasename: string
+  workspaceId: string
 }
 
 export function packageRootFromImportMeta (importMetaUrl = import.meta.url): string {
@@ -83,23 +96,33 @@ export function defaultHostAgentsDir (env: NodeJS.ProcessEnv = process.env): str
   return join(env.HOME ?? homedir(), '.agents')
 }
 
-export function createWorkspaceContext (options: WorkspaceContextOptions = {}): WorkspaceContext {
+export function defaultHostCodexAuthPath (env: NodeJS.ProcessEnv = process.env): string {
+  return join(env.HOME ?? homedir(), '.codex', 'auth.json')
+}
+
+export function defaultHostGitconfigPath (env: NodeJS.ProcessEnv = process.env): string {
+  return join(env.HOME ?? homedir(), '.gitconfig')
+}
+
+export function createWorkspaceContextFromIdentity (
+  identity: WorkspaceContextIdentity,
+  options: Omit<WorkspaceContextOptions, 'workspace' | 'cwd'> = {}
+): WorkspaceContext {
   const env = options.env ?? process.env
-  const workspaceFolder = resolveWorkspaceFolder(options.workspace, options.cwd)
-  const workspaceBasename = basename(workspaceFolder)
-  const workspaceId = workspaceIdFor(workspaceFolder)
   const packageRoot = options.packageRoot ?? packageRootFromImportMeta()
   const assetsDevcontainerDir = options.assetsDevcontainerDir ?? env.BOXDOWN_DEVCONTAINER_ASSETS_DIR ?? join(packageRoot, 'assets', 'devcontainer')
   const cacheRoot = defaultCacheRoot(env)
   const dataRoot = defaultDataRoot(env)
   const hostAgentsDir = defaultHostAgentsDir(env)
-  const workspaceCacheDir = join(cacheRoot, 'workspaces', workspaceId)
-  const workspaceDataDir = join(dataRoot, 'workspaces', workspaceId)
+  const hostCodexAuthPath = defaultHostCodexAuthPath(env)
+  const workspaceCacheDir = join(cacheRoot, 'workspaces', identity.workspaceId)
+  const workspaceDataDir = join(dataRoot, 'workspaces', identity.workspaceId)
+  const hostGitconfigSnapshotDir = join(workspaceDataDir, 'gitconfig')
 
   return {
-    workspaceFolder,
-    workspaceBasename,
-    workspaceId,
+    workspaceFolder: identity.workspaceFolder,
+    workspaceBasename: identity.workspaceBasename,
+    workspaceId: identity.workspaceId,
     packageRoot,
     assetsDevcontainerDir,
     cacheRoot,
@@ -108,10 +131,27 @@ export function createWorkspaceContext (options: WorkspaceContextOptions = {}):
     workspaceDataDir,
     generatedConfigPath: join(workspaceCacheDir, 'devcontainer.json'),
     hostAgentsDir,
+    hostCodexAuthPath,
+    hostGitconfigPath: defaultHostGitconfigPath(env),
+    hostGitconfigSnapshotDir,
+    hostGitconfigSnapshotPath: join(hostGitconfigSnapshotDir, '.gitconfig'),
+    gitSigningStateDir: join(workspaceDataDir, 'git-signing'),
+    gitSigningPublicKeyPath: join(workspaceDataDir, 'git-signing', 'signing-key.pub'),
     sshKeyDir: join(workspaceDataDir, 'ssh'),
     sshKeyPath: join(workspaceDataDir, 'ssh', 'id_ed25519'),
     sshPublicKeyPath: join(workspaceDataDir, 'ssh', 'id_ed25519.pub'),
     sshPublicKeyRuntimeDir: join(workspaceDataDir, 'ssh-public'),
-    sshPublicKeyRuntimePath: join(workspaceDataDir, 'ssh-public', 'id_ed25519.pub')
+    sshPublicKeyRuntimePath: join(workspaceDataDir, 'ssh-public', 'id_ed25519.pub'),
+    workspaceLogPath: join(workspaceDataDir, 'boxdown.log')
   }
 }
+
+export function createWorkspaceContext (options: WorkspaceContextOptions = {}): WorkspaceContext {
+  const workspaceFolder = resolveWorkspaceFolder(options.workspace, options.cwd)
+
+  return createWorkspaceContextFromIdentity({
+    workspaceFolder,
+    workspaceBasename: basename(workspaceFolder),
+    workspaceId: workspaceIdFor(workspaceFolder)
+  }, options)
+}

package/src/process.ts

@@ -1,4 +1,7 @@
 import { spawn } from 'node:child_process'
+import { delimiter } from 'node:path'
+
+import type { WorkspaceCommandLogger } from './logging.ts'
 
 export interface BufferedCommandOptions {
   cwd?: string
@@ -6,6 +9,9 @@ export interface BufferedCommandOptions {
   input?: string
   mirrorStdout?: 'stdout' | 'stderr' | false
   mirrorStderr?: 'stdout' | 'stderr' | false
+  logger?: WorkspaceCommandLogger
+  onStdout?: (chunk: Buffer) => void
+  onStderr?: (chunk: Buffer) => void
 }
 
 export interface CommandResult {
@@ -15,10 +21,58 @@ export interface CommandResult {
 }
 
 function mergedEnv (env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv {
-  return {
+  const baseEnv = {
     ...process.env,
     ...(env ?? {})
   }
+
+  return {
+    ...baseEnv,
+    PATH: buildHostToolPath(baseEnv)
+  }
+}
+
+function uniquePathEntries (entries: readonly string[]): string[] {
+  const seen = new Set<string>()
+  const result: string[] = []
+
+  for (const entry of entries) {
+    if (entry.length === 0 || seen.has(entry)) {
+      continue
+    }
+
+    seen.add(entry)
+    result.push(entry)
+  }
+
+  return result
+}
+
+export function buildHostToolPath (env: NodeJS.ProcessEnv = process.env): string {
+  const home = env.HOME
+  const existingPath = env.PATH ?? ''
+  const configuredPrefix = env.BOXDOWN_HOST_PATH_PREFIX?.split(delimiter) ?? []
+  const guiFriendlyPrefix = [
+    ...(home === undefined ? [] : [
+      `${home}/.local/bin`,
+      `${home}/.docker/bin`
+    ]),
+    '/opt/homebrew/bin',
+    '/opt/homebrew/sbin',
+    '/usr/local/bin',
+    '/usr/local/sbin',
+    '/Applications/Docker.app/Contents/Resources/bin',
+    '/usr/bin',
+    '/bin',
+    '/usr/sbin',
+    '/sbin'
+  ]
+
+  return uniquePathEntries([
+    ...configuredPrefix,
+    ...existingPath.split(delimiter),
+    ...guiFriendlyPrefix
+  ]).join(delimiter)
 }
 
 function writeChunk (target: 'stdout' | 'stderr' | false, chunk: Buffer): void {
@@ -31,6 +85,7 @@ function writeChunk (target: 'stdout' | 'stderr' | false, chunk: Buffer): void {
 
 export function runBuffered (command: string, args: string[], options: BufferedCommandOptions = {}): Promise<CommandResult> {
   return new Promise((resolve) => {
+    const loggedCommand = options.logger?.startCommand(command, args, { cwd: options.cwd })
     const child = spawn(command, args, {
       cwd: options.cwd,
       env: mergedEnv(options.env),
@@ -42,15 +97,28 @@ export function runBuffered (command: string, args: string[], options: BufferedC
 
     child.stdout.on('data', (chunk: Buffer) => {
       stdoutChunks.push(chunk)
+      loggedCommand?.stream('stdout', chunk)
+      options.onStdout?.(chunk)
       writeChunk(options.mirrorStdout ?? 'stdout', chunk)
     })
 
     child.stderr.on('data', (chunk: Buffer) => {
       stderrChunks.push(chunk)
+      loggedCommand?.stream('stderr', chunk)
+      options.onStderr?.(chunk)
       writeChunk(options.mirrorStderr ?? 'stderr', chunk)
     })
 
+    let resolved = false
+
     child.on('error', (error) => {
+      if (resolved) {
+        return
+      }
+
+      resolved = true
+      loggedCommand?.error(error)
+      loggedCommand?.finish(127)
       resolve({
         code: 127,
         stdout: Buffer.concat(stdoutChunks).toString('utf8'),
@@ -59,6 +127,12 @@ export function runBuffered (command: string, args: string[], options: BufferedC
     })
 
     child.on('close', (code) => {
+      if (resolved) {
+        return
+      }
+
+      resolved = true
+      loggedCommand?.finish(code ?? 1)
       resolve({
         code: code ?? 1,
         stdout: Buffer.concat(stdoutChunks).toString('utf8'),
@@ -74,8 +148,9 @@ export function runBuffered (command: string, args: string[], options: BufferedC
   })
 }
 
-export function runInteractive (command: string, args: string[], options: Pick<BufferedCommandOptions, 'cwd' | 'env'> = {}): Promise<number> {
+export function runInteractive (command: string, args: string[], options: Pick<BufferedCommandOptions, 'cwd' | 'env' | 'logger'> = {}): Promise<number> {
   return new Promise((resolve) => {
+    const loggedCommand = options.logger?.startCommand(command, args, { cwd: options.cwd })
     const child = spawn(command, args, {
       cwd: options.cwd,
       env: mergedEnv(options.env),
@@ -83,11 +158,14 @@ export function runInteractive (command: string, args: string[], options: Pick<B
     })
 
     child.on('error', (error) => {
+      loggedCommand?.error(error)
+      loggedCommand?.finish(127)
       process.stderr.write(`${error.message}\n`)
       resolve(127)
     })
 
     child.on('close', (code) => {
+      loggedCommand?.finish(code ?? 1)
       resolve(code ?? 1)
     })
   })