Apr 22, 2025 · Mar 18, 2025 · Mar 18, 2025 · Mar 18, 2025 · Mar 18, 2025 · Mar 18, 2025
diff --git a/src/api.ts b/src/api.ts
  writeEmitter.fire(`Workspace is now ${updatedWorkspace.latest_build.status}\r\n`)
  return updatedWorkspace
 }

 // 1. First, get a workspace by owner and name
 export async function getAITasksForWorkspace(
  restClient: Api,
  writeEmitter: vscode.EventEmitter<string>,
  workspace: Workspace,
 ): Promise<WorkspaceAgentTask[]> {
  // We need to build up tasks
  let awaiting_tasks: WorkspaceAgentTask[] = [];

  // The workspace will include agents, and within each agent you can find tasks
  // You can access the agents from the workspace resource
  const resources = workspace.latest_build.resources;

  // Go through each resource
  for (const resource of resources) {
    if (!resource.agents) {
      continue
    }

    resource.agents.forEach((agent) => {
      for (const task of agent.tasks) {
        awaiting_tasks.push(task);
      }
    })
  }

  return awaiting_tasks;
 }
diff --git a/src/commands.ts b/src/commands.ts
 import { getErrorMessage } from "coder/site/src/api/errors"
 import { User, Workspace, WorkspaceAgent } from "coder/site/src/api/typesGenerated"
 import * as vscode from "vscode"
 import {getAITasksForWorkspace,makeCoderSdk, needToken } from "./api"
 import { makeCoderSdk, needToken } from "./api"
 import { extractAgents } from "./api-helper"
 import { CertificateError } from "./error"
 import { Storage } from "./storage"
    const doc = await vscode.workspace.openTextDocument(uri)
    await vscode.window.showTextDocument(doc)
  }


  /**
   * Log out from the currently logged-in deployment.
  }

  public async openAISession(): Promise<void> {

    // Then launch an integrated terminal with screen session
    const terminal = vscode.window.createTerminal({
      name: "Claude Code Session",
    })


    // Show the terminal and run the screen command
    terminal.show(true)
    terminal.sendText("screen -xRR claude-code")
diff --git a/src/workspacesProvider.ts b/src/workspacesProvider.ts
 import { EventSource } from "eventsource"
 import * as path from "path"
 import * as vscode from "vscode"
 import { createStreamingFetchAdapter, getAITasksForWorkspace } from "./api"
 import { createStreamingFetchAdapter } from "./api"
 import {
  AgentMetadataEvent,
  AgentMetadataEventSchemaArray,
    })

    // Create tree items for each workspace
    const workspaceTreeItems = await Promise.all(resp.workspaces.map(async (workspace) => {
      const workspaceTreeItem = new WorkspaceTreeItem(
        workspace,
        this.getWorkspacesQuery === WorkspaceQuery.All,
        showMetadata
      )

      // Fetch AI tasks for the workspace
      try {
        // Create a dummy emitter for logs
        const emitter = new vscode.EventEmitter<string>()
        const aiTasks = await getAITasksForWorkspace(restClient, emitter, workspace)
        workspaceTreeItem.aiTasks = aiTasks
        this.storage.writeToCoderOutputChannel(aiTasks.length.toString())
        console.log(aiTasks.length.toString())
      } catch (error) {
        // Log the error but continue - we don't want to fail the whole tree if AI tasks fail
        this.storage.writeToCoderOutputChannel(`Failed to fetch AI tasks for workspace ${workspace.name}: ${errToStr(error, "unknown error")}`)

      }

      return workspaceTreeItem
    }))
    const workspaceTreeItems = await Promise.all(
      resp.workspaces.map(async (workspace) => {
        const workspaceTreeItem = new WorkspaceTreeItem(
          workspace,
          this.getWorkspacesQuery === WorkspaceQuery.All,
          showMetadata,
        )

        // Fetch AI tasks for the workspace
        try {
          // Create a dummy emitter for logs
          const emitter = new vscode.EventEmitter<string>()
        } catch (error) {
          // Log the error but continue - we don't want to fail the whole tree if AI tasks fail
          this.storage.writeToCoderOutputChannel(
            `Failed to fetch AI tasks for workspace ${workspace.name}: ${errToStr(error, "unknown error")}`,
          )
        }

        return workspaceTreeItem
      }),
    )

    return workspaceTreeItems
  }
        const agentTreeItems = agents.map(
          (agent) => new AgentTreeItem(agent, element.workspaceOwner, element.workspaceName, element.watchMetadata),
        )

        // Add AI task items to the workspace children if there are any
        const aiTaskItems = element.aiTasks.map(task => new AITaskTreeItem(task))

        // If there are AI tasks, add them at the beginning of the list
        if (aiTaskItems.length == 0) {
          return Promise.resolve(agentTreeItems)
        }

        // Return AI task items first, then a separator, then agent items
        return Promise.resolve([...aiTaskItems, ...agentTreeItems])

        return Promise.resolve(agentTreeItems)
      } else if (element instanceof AgentTreeItem) {
        const watcher = this.agentWatchers[element.agent.id]
        if (watcher?.error) {
          return Promise.resolve([new ErrorTreeItem(watcher.error)])
        }

        const items: vscode.TreeItem[] = []

        // Add AI tasks first, if the agent has any associated tasks
        const agentTasks = element.agent.tasks.map((task) => new AITaskTreeItem(task))
        items.push(...agentTasks)

        // Add agent metadata
        const savedMetadata = watcher?.metadata || []
        return Promise.resolve(savedMetadata.map((metadata) => new AgentMetadataTreeItem(metadata)))
        items.push(...savedMetadata.map((metadata) => new AgentMetadataTreeItem(metadata)))

        return Promise.resolve(items)
      }

      return Promise.resolve([])

 class AITaskTreeItem extends vscode.TreeItem {
  constructor(public readonly task: WorkspaceAgentTask) {
    super(task.summary, vscode.TreeItemCollapsibleState.None)
    // Add a hand raise emoji (✋) to indicate tasks awaiting user input
    super(task.icon, vscode.TreeItemCollapsibleState.None)
    this.description = task.summary
    this.contextValue = "coderAITask"

    // Add an icon using VSCode's built-in Codicons
    this.iconPath = new vscode.ThemeIcon("sparkle")


    // Add command to handle clicking on the task
    this.command = {
      command: "coder.openAITask",
      command: "coder.openAITask",
      title: "Open AI Task",
      arguments: [task]
      arguments: [task],
    }
  }
 }
      agent.expanded_directory,
      "coderAgent",
    )

    if (agent.task_waiting_for_user_input) {
      this.label = "🙋 " + this.label;
    }
  }
 }

 export class WorkspaceTreeItem extends OpenableTreeItem {
  public aiTasks: WorkspaceAgentTask[] = []

  public aiTasks:{waiting: boolean, tasks:WorkspaceAgentTask[]}[] = []

  constructor(
    public readonly workspace: Workspace,
    public readonly showOwner: boolean,
Original file line number	Diff line number	Diff line change
Expand Up		@@ -276,32 +276,3 @@ export async function waitForBuild(
		writeEmitter.fire(`Workspace is now ${updatedWorkspace.latest_build.status}\r\n`)
		return updatedWorkspace
		}

		// 1. First, get a workspace by owner and name
		export async function getAITasksForWorkspace(
		restClient: Api,
		writeEmitter: vscode.EventEmitter<string>,
		workspace: Workspace,
		): Promise<WorkspaceAgentTask[]> {
		// We need to build up tasks
		let awaiting_tasks: WorkspaceAgentTask[] = [];

		// The workspace will include agents, and within each agent you can find tasks
		// You can access the agents from the workspace resource
		const resources = workspace.latest_build.resources;

		// Go through each resource
		for (const resource of resources) {
		if (!resource.agents) {
		continue
		}

		resource.agents.forEach((agent) => {
		for (const task of agent.tasks) {
		awaiting_tasks.push(task);
		}
		})
		}

		return awaiting_tasks;
		}
Original file line number	Diff line number	Diff line change
Expand Up		@@ -2,7 +2,7 @@ import { Api } from "coder/site/src/api/api"
		import { getErrorMessage } from "coder/site/src/api/errors"
		import { User, Workspace, WorkspaceAgent } from "coder/site/src/api/typesGenerated"
		import * as vscode from "vscode"
		import {getAITasksForWorkspace,makeCoderSdk, needToken } from "./api"
		import { makeCoderSdk, needToken } from "./api"
		import { extractAgents } from "./api-helper"
		import { CertificateError } from "./error"
		import { Storage } from "./storage"
Expand DownExpand Up		@@ -295,7 +295,6 @@ export class Commands {
		const doc = await vscode.workspace.openTextDocument(uri)
		await vscode.window.showTextDocument(doc)
		}


		/**
		* Log out from the currently logged-in deployment.
Expand DownExpand Up		@@ -409,12 +408,11 @@ export class Commands {
		}

		public async openAISession(): Promise<void> {

		// Then launch an integrated terminal with screen session
		const terminal = vscode.window.createTerminal({
		name: "Claude Code Session",
		})


		// Show the terminal and run the screen command
		terminal.show(true)
		terminal.sendText("screen -xRR claude-code")
Expand Down
Original file line number	Diff line number	Diff line change
Expand Up		@@ -3,7 +3,7 @@ import { Workspace, WorkspaceAgent, WorkspaceAgentTask } from "coder/site/src/ap
		import { EventSource } from "eventsource"
		import * as path from "path"
		import * as vscode from "vscode"
		import { createStreamingFetchAdapter, getAITasksForWorkspace } from "./api"
		import { createStreamingFetchAdapter } from "./api"
		import {
		AgentMetadataEvent,
		AgentMetadataEventSchemaArray,
Expand DownExpand Up		@@ -147,29 +147,28 @@ export class WorkspaceProvider implements vscode.TreeDataProvider<vscode.TreeIte
		})

		// Create tree items for each workspace
		const workspaceTreeItems = await Promise.all(resp.workspaces.map(async (workspace) => {
		const workspaceTreeItem = new WorkspaceTreeItem(
		workspace,
		this.getWorkspacesQuery === WorkspaceQuery.All,
		showMetadata
		)

		// Fetch AI tasks for the workspace
		try {
		// Create a dummy emitter for logs
		const emitter = new vscode.EventEmitter<string>()
		const aiTasks = await getAITasksForWorkspace(restClient, emitter, workspace)
		workspaceTreeItem.aiTasks = aiTasks
		this.storage.writeToCoderOutputChannel(aiTasks.length.toString())
		console.log(aiTasks.length.toString())
		} catch (error) {
		// Log the error but continue - we don't want to fail the whole tree if AI tasks fail
		this.storage.writeToCoderOutputChannel(`Failed to fetch AI tasks for workspace ${workspace.name}: ${errToStr(error, "unknown error")}`)

		}

		return workspaceTreeItem
		}))
		const workspaceTreeItems = await Promise.all(
		resp.workspaces.map(async (workspace) => {
		const workspaceTreeItem = new WorkspaceTreeItem(
		workspace,
		this.getWorkspacesQuery === WorkspaceQuery.All,
		showMetadata,
		)

		// Fetch AI tasks for the workspace
		try {
		// Create a dummy emitter for logs
		const emitter = new vscode.EventEmitter<string>()
		} catch (error) {
		// Log the error but continue - we don't want to fail the whole tree if AI tasks fail
		this.storage.writeToCoderOutputChannel(
		`Failed to fetch AI tasks for workspace ${workspace.name}: ${errToStr(error, "unknown error")}`,
		)
		}

		return workspaceTreeItem
		}),
		)

		return workspaceTreeItems
		}
Expand DownExpand Up		@@ -230,24 +229,25 @@ export class WorkspaceProvider implements vscode.TreeDataProvider<vscode.TreeIte
		const agentTreeItems = agents.map(
		(agent) => new AgentTreeItem(agent, element.workspaceOwner, element.workspaceName, element.watchMetadata),
		)

		// Add AI task items to the workspace children if there are any
		const aiTaskItems = element.aiTasks.map(task => new AITaskTreeItem(task))

		// If there are AI tasks, add them at the beginning of the list
		if (aiTaskItems.length == 0) {
		return Promise.resolve(agentTreeItems)
		}

		// Return AI task items first, then a separator, then agent items
		return Promise.resolve([...aiTaskItems, ...agentTreeItems])

		return Promise.resolve(agentTreeItems)
		} else if (element instanceof AgentTreeItem) {
		const watcher = this.agentWatchers[element.agent.id]
		if (watcher?.error) {
		return Promise.resolve([new ErrorTreeItem(watcher.error)])
		}

		const items: vscode.TreeItem[] = []

		// Add AI tasks first, if the agent has any associated tasks
		const agentTasks = element.agent.tasks.map((task) => new AITaskTreeItem(task))
		items.push(...agentTasks)

		// Add agent metadata
		const savedMetadata = watcher?.metadata \|\| []
		return Promise.resolve(savedMetadata.map((metadata) => new AgentMetadataTreeItem(metadata)))
		items.push(...savedMetadata.map((metadata) => new AgentMetadataTreeItem(metadata)))

		return Promise.resolve(items)
		}

		return Promise.resolve([])
Expand DownExpand Up		@@ -320,18 +320,16 @@ class AgentMetadataTreeItem extends vscode.TreeItem {

		class AITaskTreeItem extends vscode.TreeItem {
		constructor(public readonly task: WorkspaceAgentTask) {
		super(task.summary, vscode.TreeItemCollapsibleState.None)
		// Add a hand raise emoji (✋) to indicate tasks awaiting user input
		super(task.icon, vscode.TreeItemCollapsibleState.None)
		this.description = task.summary
		this.contextValue = "coderAITask"

		// Add an icon using VSCode's built-in Codicons
		this.iconPath = new vscode.ThemeIcon("sparkle")


		// Add command to handle clicking on the task
		this.command = {
		command: "coder.openAITask",
		command: "coder.openAITask",
		title: "Open AI Task",
		arguments: [task]
		arguments: [task],
		}
		}
		}
Expand DownExpand Up		@@ -382,12 +380,16 @@ class AgentTreeItem extends OpenableTreeItem {
		agent.expanded_directory,
		"coderAgent",
		)

		if (agent.task_waiting_for_user_input) {
		this.label = "🙋 " + this.label;
		}
		}
		}

		export class WorkspaceTreeItem extends OpenableTreeItem {
		public aiTasks: WorkspaceAgentTask[] = []

		public aiTasks:{waiting: boolean, tasks:WorkspaceAgentTask[]}[] = []

		constructor(
		public readonly workspace: Workspace,
		public readonly showOwner: boolean,
Expand Down